@weasel-js/core 1.3.0 → 1.4.0-pre.0

package/dist/renderer.d.ts

@@ -1,204 +1,12 @@
-import { M as Mesh, S as ShaderProgram, I as ImageMinification, G as GLImageCache } from './stroke-5pBwOm9s.js';
-export { a as ShaderCompileError, b as SpriteSheet, c as StrokeOptions, V as ViewLike, f as frameRect, t as tessellateStroke, v as viewToMat3 } from './stroke-5pBwOm9s.js';
-import { GradStop, TextureHandle } from '@weasel-js/paint';
-export { TextureHandle } from '@weasel-js/paint';
-import { M as Mat3, S as ShaderProgramHandle, D as DrawCommand } from './DrawCommand-BnZyQaDc.js';
-export { G as GroupDrawCommand, I as ImageDrawCommand, P as PathDrawCommand, a as ShaderDrawCommand, b as ShaderUniform, c as SolidPaint, T as TextDrawCommand, m as mat3, r as registerProgram } from './DrawCommand-BnZyQaDc.js';
+import { M as Mesh } from './stroke-B_BxktoE.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 buildGradientRamp, f as frameRect, t as tessellateStroke, v as viewToMat3 } from './stroke-B_BxktoE.js';
+export { D as DrawCommand, G as GroupDrawCommand, I as ImageDrawCommand, M as Mat3, P as PathDrawCommand, S as ShaderDrawCommand, a as ShaderProgramHandle, b as ShaderUniform, c as SolidPaint, T as TextDrawCommand, m as mat3, r as registerProgram } from './DrawCommand-b-z1bCT-.js';
 import { P as Path } from './path-JEV2c5If.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';
 
-interface GLMeshHandle {
-    readonly vao: WebGLVertexArrayObject;
-    readonly indexCount: number;
-    readonly requiresStencil: boolean;
-    readonly anchorA?: Uint32Array;
-    readonly anchorB?: Uint32Array;
-    readonly anchorT?: Float32Array;
-}
-/** Resources to release when a Mesh is reclaimed by GC. */
-interface MeshResources {
-    vao: WebGLVertexArrayObject;
-    vbo: WebGLBuffer;
-    ibo: WebGLBuffer;
-}
-/**
- * Caches GL-side buffers + VAO per `Mesh` identity. Upload happens lazily
- * on first `handleFor(mesh)` call.
- *
- * **GC-aware cleanup (deferred-delete queue):** when a Mesh becomes
- * unreachable, the WeakMap entry is dropped automatically — but the
- * underlying GL resources (VAO, VBO, IBO) would leak forever without an
- * explicit `gl.delete*` call. We register each Mesh with a
- * `FinalizationRegistry`; when the Mesh is reclaimed, the finalizer pushes
- * the resources onto an internal queue. The renderer drains this queue at
- * the start of each `render()` call (via `drainPendingDeletes()`), when GL
- * is in a known state — no VAO bound, no draw mid-flight. Deleting from the
- * finalizer directly was racy (it could fire between two `gl.bindVertexArray`
- * calls inside `dispatch()`, sometimes corrupting the next draw); deferring
- * the actual delete to a known-safe point keeps the use-after-free risk to
- * zero.
- *
- * Caveats:
- *   - Finalizer timing is non-deterministic; resources may live for a frame
- *     or two beyond their Mesh, but they will be reclaimed.
- *   - If the GL context is lost between finalizer and drain, the drain
- *     no-ops safely (`gl.isContextLost()` makes deletes no-ops, and
- *     `gl.deleteBuffer(null)` is allowed).
- *
- * The cache is GL-context-bound; if the context is lost and re-created, the
- * renderer should construct a new GLMeshCache. (Context loss handling lives
- * in `WeaselRenderer`.)
- */
-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(). */
-    private readonly transientThisFrame;
-    constructor(gl: WebGL2RenderingContext, aPositionLoc: number);
-    handleFor(mesh: Mesh): GLMeshHandle;
-    /**
-     * Upload a Mesh that the caller knows is single-use (e.g. the per-frame
-     * stroke ribbon from `tessellateStroke`). Returns a handle backed by fresh
-     * GL resources that the renderer will free deterministically at the end
-     * of the current frame via `freeTransient()`. Bypasses the WeakMap cache
-     * 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.
-     */
-    freeTransient(): void;
-    /** @internal — for tests asserting the transient-list size. */
-    _transientCount(): number;
-    /**
-     * Free GL resources whose Mesh has been GC'd since the last drain.
-     * Called by the renderer at the top of each `render()`, before any draws.
-     */
-    drainPendingDeletes(): void;
-    /** @internal — for tests asserting the queue size. */
-    _pendingDeleteCount(): number;
-    /** @internal — for tests that need to simulate the finalizer firing. */
-    _enqueueDeleteForTest(resources: MeshResources): void;
-    private upload;
-}
-
-/**
- * GL texture upload + cache for MSDF font atlases (and future images).
- *
- * Textures are keyed by a string id (the font family name or image id).
- * Pixels are uploaded once per id; a later upload of the same id reuses the
- * texture and only re-applies its wrap mode when that changed.
- * The cache is GL-context-bound; discard and create a new one on context loss.
- *
- * Atlas format: RGBA UNSIGNED_BYTE, linear filtering, no mipmaps.
- * Mipmap generation is deliberately skipped — MSDF works correctly with
- * linear filtering, and mipmap resampling corrupts the multi-channel SDF signal.
- */
-type TexSource = HTMLImageElement | ImageBitmap | ImageData | HTMLCanvasElement;
-/** How a texture samples outside `0..1`. Pattern tiles need `'repeat'`;
- *  everything else clamps. WebGL2 allows `REPEAT` on NPOT textures, so a
- *  tile of any size tiles correctly. */
-type TextureWrap = 'clamp' | 'repeat';
-declare class GLTextureCache {
-    private readonly gl;
-    private readonly map;
-    private readonly wraps;
-    constructor(gl: WebGL2RenderingContext);
-    has(id: string): boolean;
-    /** Uploads the pixels once per id. `wrap` is re-applied whenever it differs
-     *  from what the id was last uploaded under: the same registered image can
-     *  be a clamped shader texture in one draw and a repeating pattern tile in
-     *  the next, and first-upload-wins gave the second one the first one's mode. */
-    upload(id: string, source: TexSource, wrap?: TextureWrap): string;
-    private applyWrap;
-    /** Create a single-channel R8 texture from raw bytes (full upload).
-     *  No-op if `id` already exists. Same LINEAR/CLAMP params as `upload`;
-     *  UNPACK_ALIGNMENT dropped to 1 for non-4-aligned row widths. */
-    uploadR8(id: string, width: number, height: number, data: Uint8Array): void;
-    /** Patch a rect of an existing R8 texture with tightly-packed w×h bytes. */
-    subImageR8(id: string, x: number, y: number, w: number, h: number, data: Uint8Array): void;
-    bind(id: string, unit: number): void;
-    /**
-     * Delete every uploaded GL texture and clear the map. Called by
-     * `WeaselRenderer.dispose()`. The cache is unusable but refillable
-     * afterward — a subsequent `upload()` for a previously-seen id re-creates
-     * the texture rather than restoring the deleted one.
-     */
-    free(): void;
-}
-
-/**
- * CPU gradient-ramp builder + GL 1×256 RGBA texture cache.
- *
- * Each unique stop list is uploaded once. Key = JSON.stringify(stops).
- * The cache is GL-context-bound; discard and recreate on context loss.
- *
- * Output convention §2: texels are stored as straight RGBA. The fragment
- * shader applies premultiplication before writing outColor.
- */
-
-/** Bake gradient stops into a 256-entry RGBA lookup strip, which the shader
- *  samples instead of evaluating stops per fragment. */
-declare function buildGradientRamp(stops: GradStop[]): Uint8ClampedArray;
-declare class GradientRampCache {
-    private readonly gl;
-    private readonly map;
-    private totalQueries;
-    private cacheHits;
-    constructor(gl: WebGL2RenderingContext);
-    upload(stops: GradStop[]): string;
-    bind(key: string, unit: number): void;
-    hitRate(): number;
-    resetStats(): void;
-    /**
-     * Delete every uploaded GL ramp texture and clear the map. Called by
-     * `WeaselRenderer.dispose()`. Only the GL textures are owned resources —
-     * `buildGradientRamp`'s CPU-side `Uint8ClampedArray` is transient per
-     * `upload()` call and already gone by the time a ramp is cached. The
-     * cache is unusable but refillable afterward (stats are left as-is; call
-     * `resetStats()` separately if desired).
-     */
-    free(): void;
-}
-
-/** Row-major 4×5 color matrix identity. */
-declare const IDENTITY_COLOR_MATRIX: Float32Array<ArrayBuffer>;
-interface GroupFrame {
-    transform?: Mat3;
-    alpha?: number;
-    /** Row-major 4×5 color matrix (20 floats). Absent leaves the stack unchanged. */
-    colorMatrix?: Float32Array | number[];
-}
-declare class GroupState {
-    private transformStack;
-    private alphaStack;
-    private colorMatrixStack;
-    get transform(): Mat3;
-    get alpha(): number;
-    get colorMatrix(): Float32Array;
-    push(frame: GroupFrame): void;
-    /** Drop every pushed frame, leaving the root. A frame that throws part-way
-     *  down the tree never pops, and the next frame would draw under leftovers. */
-    reset(): void;
-    pop(): void;
-}
-
 /**
  * registerTexture — accepts an image source, assigns an opaque id, stores in
  * a module-level registry. Actual GL upload happens lazily at draw time in
@@ -221,221 +29,6 @@ declare class GroupState {
  */
 declare function registerTexture(image: HTMLImageElement | ImageBitmap): TextureHandle;
 
-/**
- * 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 aPos;
-    private readonly aColor;
-    /** Cycled per flush, and created on first use so a renderer that flushes
-     *  rarely allocates as few slots as it flushes. */
-    private readonly ring;
-    private next;
-    /** The same, for flushes past a slot's capacity; these sets grow to fit. */
-    private readonly largeRing;
-    private nextLarge;
-    private verts;
-    private idx;
-    private nVerts;
-    private nIdx;
-    /** Whether the staged run is rects alone, so its indices are the canonical
-     *  quad pattern and a slot already holding that pattern needs no upload. */
-    private pureRects;
-    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 into the next set of buffers and bind its 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;
-    private nextRingSlot;
-    private nextLargeSlot;
-    private createSet;
-    private deleteSet;
-}
-
-/** How to construct a `WeaselRenderer`: the GL context or canvas to draw
- *  into, the output size, and the quality knobs that separate screen
- *  rendering from print. */
-interface WeaselRendererOptions {
-    gl?: WebGL2RenderingContext;
-    canvas?: HTMLCanvasElement;
-    width: number;
-    height: number;
-    dpr: number;
-    /** MIN_FILTER strategy for image/pattern textures (`GLImageCache`).
-     *  Default `'linear'` — the existing screen behavior. The headless
-     *  `renderSceneToPixels` path passes `'mipmap'` for print-quality
-     *  minification. Explicitly passing `'linear'` is always valid. */
-    imageMinification?: ImageMinification;
-    /** Flatness tolerance for curve tessellation, in WORLD units (see
-     *  `TessellateOptions.flattenTolerance`). When set, path fills are
-     *  tessellated fresh at this tolerance per frame (transient pool) instead
-     *  of served from the Path-identity mesh cache — the cache key does not
-     *  include tolerance. Default: unset — the existing cached behavior at
-     *  `DEFAULT_FLATTEN_TOLERANCE`. The headless path derives this from the
-     *  requested output scale; screen callers normally leave it unset. */
-    flattenTolerance?: number;
-    /** Per-render synchronous bake budget for dynamic canvas-SDF glyphs.
-     *  Default DEFAULT_BAKE_BUDGET (16). The headless renderSceneToPixels
-     *  path passes Infinity so print never defers a glyph. */
-    bakeBudget?: number;
-    /** On-screen glyph size, in CSS pixels, at or above which text renders from
-     *  tessellated font outlines instead of a distance field — see
-     *  `OUTLINE_MIN_SCREEN_PX`. Only faces registered with
-     *  `registerFontOutlines` are affected; everything else keeps its SDF tier
-     *  whatever this says. Pass `Infinity` to disable the tier outright, or 0
-     *  to use outlines wherever they exist (what the headless path does, since
-     *  print has no reason to sample a field it could evaluate exactly). */
-    textOutlineMinScreenSize?: number;
-}
-/**
- * The WebGL2 renderer: takes a list of draw commands and paints them.
- *
- * It knows nothing about the scene — commands are the whole interface, which
- * is what lets layers, HUD widgets and overlays all draw through the same
- * pipeline. GPU resources (meshes, textures, gradient ramps) are cached across
- * frames and keyed by identity, so re-issuing the same command is cheap.
- */
-declare class WeaselRenderer {
-    private readonly gl;
-    private pathFill;
-    private pathFillVColor;
-    private textSdf;
-    private textSdfR8;
-    private imageFill;
-    private gradFill;
-    private patternFill;
-    private meshCache;
-    private textureCache;
-    private imageCache;
-    private gradRampCache;
-    private programRegistry;
-    private quadVbo;
-    private quadIbo;
-    private solidBatch;
-    private readonly groupState;
-    private widthCss;
-    private heightCss;
-    private dpr;
-    private canvas;
-    private readonly imageMinification;
-    private readonly flattenTolerance?;
-    private readonly bakeBudget;
-    private readonly textOutlineMinScreenSize;
-    private contextLost;
-    private boundOnLost;
-    private boundOnRestored;
-    /** True after `dispose()`. A disposed renderer ignores further `render()`
-     *  calls and `registerProgram()` calls. */
-    private disposed;
-    constructor(opts: WeaselRendererOptions);
-    private uploadQuadGeometry;
-    /**
-     * Compile a consumer-registered shader program against this renderer's GL context.
-     *
-     * Call once per renderer after the module-level `registerProgram()`.
-     * Throws `ShaderCompileError` if compilation fails.
-     *
-     * In dev mode, calling again with the same handle replaces the compiled program.
-     *
-     * @experimental
-     */
-    registerProgram(handle: ShaderProgramHandle): void;
-    /**
-     * The compiled program for `id`, compiling it against this context on first
-     * use. Unlike {@link registerProgram} this neither throws on a missing
-     * source nor on a compile failure: a paint kind asking for a program it
-     * never registered must decline the paint, not take down the frame.
-     */
-    private ensureProgram;
-    private applyViewport;
-    isContextLost(): boolean;
-    private onContextLost;
-    private onContextRestored;
-    /** Free the GL resources this renderer itself owns and detach context-loss
-     *  listeners when a canvas was supplied. Idempotent.
-     *
-     *  Scope: built-in shader programs, any consumer-registered programs, the
-     *  shared quad/rect geometry, any in-flight transient meshes, and the
-     *  enumerable Map-keyed caches (`GLTextureCache` atlas/image textures,
-     *  `GradientRampCache` ramp textures) ARE freed.
-     *
-     *  NOT freed: `GLImageCache` (bitmap/pattern textures) and `GLMeshCache`'s
-     *  persistent per-Path mesh cache are keyed by `WeakMap`, not enumerable,
-     *  and are only reclaimed when the GL context itself goes away (cf.
-     *  `GLImageCache`'s own "deferred to v2" note). On a caller-owned
-     *  long-lived context — the headless render-to-pixels path hands the same
-     *  `gl` to many short-lived renderers — the image/pattern textures and
-     *  persistent Path meshes each renderer uploads DO accumulate across
-     *  renderer instances until the caller recycles the context.
-     *
-     *  Also: a Mesh that gets GC'd after `dispose()` still lands in
-     *  `GLMeshCache`'s `pendingDeletes` queue via its `FinalizationRegistry`,
-     *  but nothing drains that queue post-dispose (only `render()` does) —
-     *  those GL resources leak until the context goes away too.
-     *
-     *  A disposed renderer ignores further `render()` and `registerProgram()`
-     *  calls. */
-    dispose(): void;
-    /**
-     * Draw one frame.
-     *
-     * `viewMatrix` is the frame's world→screen transform. It is only consulted
-     * by `units: 'world'` gradients, which fall back to screen space without
-     * it — every other command carries its own transform in the stream, so
-     * callers with no view concept can keep calling `render(commands)`.
-     */
-    render(commands: DrawCommand[], viewMatrix?: Mat3): void;
-    resize(dims: {
-        width: number;
-        height: number;
-        dpr: number;
-    }): void;
-    /** @internal */ _gl(): WebGL2RenderingContext;
-    /** @internal */ _pathFill(): ShaderProgram;
-    /** @internal */ _pathFillVColor(): ShaderProgram;
-    /** @internal */ _solidBatch(): SolidBatch;
-    /** @internal */ _textSdf(): ShaderProgram;
-    /** @internal */ _textSdfR8(): ShaderProgram;
-    /** @internal */ _imageFill(): ShaderProgram;
-    /** @internal */ _gradFill(): ShaderProgram;
-    /** @internal */ _patternFill(): ShaderProgram;
-    /** @internal */ _meshCache(): GLMeshCache;
-    /** @internal */ _textureCache(): GLTextureCache;
-    /** @internal */ _imageCache(): GLImageCache;
-    /** @internal */ _gradRampCache(): GradientRampCache;
-    /** @internal */ _groupState(): GroupState;
-    /** @internal */ _widthCss(): number;
-    /** @internal */ _heightCss(): number;
-    /** @internal */ _dpr(): number;
-}
-
 /** Options for `tessellate`. A smaller tolerance means more triangles and
  *  smoother curves; it is in path-local units, so callers rendering at a
  *  larger scale should tighten it. */
@@ -462,4 +55,4 @@ declare function tessellate(path: Path, opts?: TessellateOptions): Mesh;
  */
 declare const OUTLINE_MIN_SCREEN_PX = 48;
 
-export { DrawCommand, IDENTITY_COLOR_MATRIX, ImageMinification, Mat3, Mesh, OUTLINE_MIN_SCREEN_PX, ShaderProgramHandle, type TessellateOptions, WeaselRenderer, type WeaselRendererOptions, buildGradientRamp, registerTexture, tessellate };
+export { Mesh, OUTLINE_MIN_SCREEN_PX, type TessellateOptions, registerTexture, tessellate };

package/dist/renderer.js

@@ -1,8 +1,8 @@
-export { IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, ShaderCompileError, WeaselRenderer, buildGradientRamp, canQueryLocalFonts, enableLocalFontOutlines, frameRect, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3 } from './chunk-N3T7D6AS.js';
-import './chunk-3ZV53ZW2.js';
-import './chunk-AQS4JGRA.js';
-import './chunk-3FB44DBC.js';
-import './chunk-F74NVEHT.js';
+export { IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, ShaderCompileError, WeaselRenderer, buildGradientRamp, canQueryLocalFonts, enableLocalFontOutlines, frameRect, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3 } from './chunk-IMFXEINV.js';
+import './chunk-H6E6KPTU.js';
+import './chunk-Y5KS66G7.js';
+import './chunk-BLJNRMKB.js';
+import './chunk-SBFC6J3C.js';
 import './chunk-67KE7SDP.js';
 import './chunk-MXFSHJOM.js';
 import './chunk-ZB7UYJVG.js';

package/dist/resize.js

@@ -1,4 +1,4 @@
-export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-3FB44DBC.js';
-export { RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR } from './chunk-F74NVEHT.js';
+export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-BLJNRMKB.js';
+export { RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR } from './chunk-SBFC6J3C.js';
 //# sourceMappingURL=resize.js.map
 //# sourceMappingURL=resize.js.map

package/dist/routing.d.ts

@@ -1,6 +1,6 @@
 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-BU1_3L_C.js';
+import { T as Tool } from './registry-sBLZYWI1.js';
 import './types-DIQAisSG.js';
 import '@weasel-js/history';
 import './path-JEV2c5If.js';
@@ -9,7 +9,7 @@ import './types-XBcDEp3Y.js';
 import './view-DSQgxBJB.js';
 import '@weasel-js/modes';
 import 'react';
-import './DrawCommand-BnZyQaDc.js';
+import './DrawCommand-b-z1bCT-.js';
 import '@weasel-js/paint';
 import '@weasel-js/text';
 import './geometry-Dtt_k6Dq.js';

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-3ZV53ZW2.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, routeGestureForSpecKind, routesForSpec } from './chunk-H6E6KPTU.js';
 //# sourceMappingURL=routing.js.map
 //# sourceMappingURL=routing.js.map