@weasel-js/core 0.5.0

package/dist/renderer.d.ts

@@ -0,0 +1,376 @@
+import { I as ImageMinification, G as GLImageCache } from './registerFont-CP-wCsrz.js';
+export { V as ViewLike, i as isCanvasFont, r as registerCanvasFont, a as registerFont, s as subscribeGlyphReady, u as unregisterCanvasFont, v as viewToMat3 } from './registerFont-CP-wCsrz.js';
+import { G as GradStop, M as Mat3, S as ShaderProgramHandle, D as DrawCommand, a as Stroke } from './DrawCommand-Dl0bXNfS.js';
+export { b as GroupDrawCommand, I as ImageDrawCommand, P as PathDrawCommand, c as ShaderDrawCommand, d as ShaderUniform, e as SolidPaint, T as TextDrawCommand, m as mat3, r as registerProgram } from './DrawCommand-Dl0bXNfS.js';
+import { P as Path } from './types-B6MMiodD.js';
+export { T as TextureHandle, r as registerTexture } from './registerTexture-BzHTLhD9.js';
+
+/**
+ * Minimal compile/link/lookup wrapper for a GL program. Throws
+ * `ShaderCompileError` on compile or link failure with the GL info log
+ * embedded in the error message — never returns a half-initialized program.
+ *
+ * Designed so test code can stub `getShaderParameter` / `getProgramParameter`
+ * via the recorder Proxy without further special-casing.
+ */
+type Stage = 'vertex' | 'fragment' | 'link';
+declare class ShaderCompileError extends Error {
+    readonly stage: Stage;
+    readonly log: string;
+    constructor(stage: Stage, log: string);
+}
+declare class ShaderProgram {
+    private readonly gl;
+    readonly handle: WebGLProgram;
+    private readonly uniforms;
+    private readonly attributes;
+    constructor(gl: WebGL2RenderingContext, vertSrc: string, fragSrc: string);
+    private compile;
+    lookupUniforms(names: readonly string[]): void;
+    lookupAttributes(names: readonly string[]): void;
+    uniform(name: string): WebGLUniformLocation | undefined;
+    attribute(name: string): number | undefined;
+}
+
+/**
+ * A tessellated representation of a Path, ready to upload to GL.
+ *
+ * - `vertices` is interleaved x,y in path-local coordinates (`Float32Array`
+ *   of length `2 * vertexCount`).
+ * - `indices` are triangle indices into `vertices` (`Uint32Array`, length
+ *   `3 * triangleCount`).
+ * - `requiresStencil` is set for paths whose fillRule is `'evenodd'` and
+ *   whose triangulation is a *naive* per-contour fan rather than a clean
+ *   inside/outside triangulation. The renderer must use a stencil
+ *   two-pass when this flag is true. Single-contour paths and `'nonzero'`
+ *   multi-contour paths leave it false.
+ * - `anchorA` / `anchorB` / `anchorT` parameterize each mesh vertex by
+ *   the two consecutive path anchors it lies between and the arc-length
+ *   fraction along that segment (0 = at A, 1 = at B). Vertices that fall
+ *   exactly on an anchor set A === B and t = 0. Used at draw time when
+ *   the DrawCommand supplies per-anchor colors so the renderer can lerp
+ *   per mesh vertex. Optional — emitted by the path tessellators; absent
+ *   on meshes built by other paths (e.g. text glyphs).
+ */
+interface Mesh {
+    readonly vertices: Float32Array;
+    readonly indices: Uint32Array;
+    readonly requiresStencil?: boolean;
+    readonly anchorA?: Uint32Array;
+    readonly anchorB?: Uint32Array;
+    readonly anchorT?: Float32Array;
+}
+
+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;
+    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;
+    /**
+     * 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).
+ * Upload happens once; subsequent uploads for the same id are no-ops.
+ * 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;
+declare class GLTextureCache {
+    private readonly gl;
+    private readonly map;
+    constructor(gl: WebGL2RenderingContext);
+    has(id: string): boolean;
+    upload(id: string, source: TexSource): string;
+    /** 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.
+ */
+
+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;
+    pop(): void;
+}
+
+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;
+}
+declare class WeaselRenderer {
+    private readonly gl;
+    private pathFill;
+    private pathFillVColor;
+    private textSdf;
+    private textSdfR8;
+    private imageFill;
+    private gradFill;
+    private meshCache;
+    private textureCache;
+    private imageCache;
+    private gradRampCache;
+    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 readonly groupState;
+    private widthCss;
+    private heightCss;
+    private dpr;
+    private canvas;
+    private readonly imageMinification;
+    private readonly flattenTolerance?;
+    private readonly bakeBudget;
+    private contextLost;
+    private boundOnLost;
+    private boundOnRestored;
+    /** True after `dispose()`. A disposed renderer ignores further `render()`
+     *  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.
+     *
+     * 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;
+    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;
+    render(commands: DrawCommand[]): void;
+    resize(dims: {
+        width: number;
+        height: number;
+        dpr: number;
+    }): void;
+    /** @internal */ _gl(): WebGL2RenderingContext;
+    /** @internal */ _pathFill(): ShaderProgram;
+    /** @internal */ _pathFillVColor(): ShaderProgram;
+    /** @internal */ _textSdf(): ShaderProgram;
+    /** @internal */ _textSdfR8(): ShaderProgram;
+    /** @internal */ _imageFill(): ShaderProgram;
+    /** @internal */ _gradFill(): 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;
+}
+
+interface TessellateOptions {
+    /** Flatness tolerance for bezier subdivision in path-local units. */
+    flattenTolerance?: number;
+}
+declare function tessellate(path: Path, opts?: TessellateOptions): Mesh;
+
+interface StrokeOptions {
+    flattenTolerance?: number;
+}
+/**
+ * Build a triangle-mesh ribbon from a stroked Path.
+ *
+ * Supports:
+ *   - cap: 'butt' | 'round' | 'square'
+ *   - join: 'miter' | 'round' | 'bevel'
+ *   - center alignment directly; RectPath inner/outer alignment via a
+ *     pre-shifted rect; PolygonPath inner/outer alignment via stencil at the
+ *     renderer level
+ *   - dash splitting
+ */
+declare function tessellateStroke(path: Path, stroke: Stroke, opts?: StrokeOptions): Mesh;
+
+export { DrawCommand, IDENTITY_COLOR_MATRIX, ImageMinification, Mat3, type Mesh, ShaderCompileError, ShaderProgramHandle, type StrokeOptions, type TessellateOptions, WeaselRenderer, type WeaselRendererOptions, buildGradientRamp, tessellate, tessellateStroke };

package/dist/renderer.js

@@ -0,0 +1,13 @@
+export { IDENTITY_COLOR_MATRIX, ShaderCompileError, WeaselRenderer, buildGradientRamp, isCanvasFont, mat3, registerCanvasFont, registerFont, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, viewToMat3 } from './chunk-7V6JEOXE.js';
+import './chunk-AM6ARSPN.js';
+import './chunk-VOVKONXA.js';
+import './chunk-BGGZ4CVF.js';
+import './chunk-CQNKCG34.js';
+import './chunk-775XXAHR.js';
+import './chunk-UGFFCMQP.js';
+import './chunk-BHVYVFGV.js';
+import './chunk-GVCNT7UH.js';
+export { registerTexture } from './chunk-Y52N27PF.js';
+import './chunk-PZ5AY32C.js';
+//# sourceMappingURL=renderer.js.map
+//# sourceMappingURL=renderer.js.map

package/dist/renderer.js.map

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

package/dist/resize.d.ts

@@ -0,0 +1,78 @@
+export { C as CORNER_ANCHORS, a as CornerAnchor, b as CornerHandle, P as PoseProjection, R as RECT_POSE_DESCRIPTOR, c as ROTATED_POSE_DESCRIPTOR, U as UseResizeOptions, d as cornerPoint, e as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle, p as pointSnapToGrid } from './pointSnapToGrid-D7s7QmOF.js';
+import { R as ResizePose, B as BoundsConstraint, M as ModifierState } from './types-BjUi2vA-.js';
+import { G as Guide } from './types-D2tTKEU0.js';
+import { V as View } from './view-DSQgxBJB.js';
+import './fitViewToBounds-evGsnR8Q.js';
+import './types-BJ8_cyT7.js';
+import '@weasel-js/history';
+import './types-B_-khFM0.js';
+
+declare function clampMinSize<TPose extends ResizePose>(args: {
+    minWidth: number;
+    minHeight: number;
+}): BoundsConstraint<TPose>;
+
+type ModKey$2 = 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`.
+ */
+declare function lockAspectWithModifier<TPose extends ResizePose>(opts?: {
+    key?: ModKey$2;
+}): BoundsConstraint<TPose>;
+
+type ModKey$1 = keyof ModifierState;
+declare function snapToGrid<TPose extends ResizePose>(args: {
+    spacing: number;
+    bypassKey?: ModKey$1;
+    suspendBelowDim?: boolean;
+}): BoundsConstraint<TPose>;
+
+type ModKey = keyof ModifierState;
+/** Options for the resize-flavored `snapToGuides`. */
+interface SnapToGuidesResizeArgs {
+    /** Stable getter into the live guide list (typically from `useGuides`). */
+    getGuides: () => readonly Guide[];
+    /** Snap tolerance (screen px when `getView` is set, world units otherwise). */
+    tolerance?: number;
+    /** Read the active view; required for screen-pixel tolerance. */
+    getView?: () => View;
+    /** Modifier key that bypasses snapping while held. */
+    bypassKey?: ModKey;
+}
+/**
+ * Resize behavior that snaps the active edge of the dragged rect to the
+ * nearest guide on the corresponding axis when within `tolerance`. The
+ * "free" axis is left untouched. The fixed (anchor) edge stays pinned;
+ * only the moving edge snaps.
+ *
+ * On the X axis, vertical guides (`axis: 'x'`) constrain the moving vertical
+ * 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>;
+
+/** 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>[];
+
+export { DEFAULT_RESIZE_BEHAVIORS, clampMinSize, lockAspectWithModifier, snapToGrid, snapToGuides };

package/dist/resize.js

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

package/dist/resize.js.map

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

package/dist/routing.css

@@ -0,0 +1,35 @@
+/* src/tools/routing/reflection/ToolDebugOverlay.module.css */
+.overlay {
+  position: absolute;
+  bottom: 12px;
+  right: 12px;
+  min-width: 180px;
+  padding: 8px 10px;
+  background: rgba(20, 20, 24, 0.86);
+  color: #eaeaea;
+  font:
+    11px/1.4 ui-monospace,
+    "SF Mono",
+    Menlo,
+    monospace;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  border-radius: 4px;
+  pointer-events: none;
+  user-select: none;
+}
+.row {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+}
+.label {
+  color: #888;
+}
+.value {
+  color: #f5f5f5;
+}
+.empty {
+  color: #888;
+  font-style: italic;
+}
+/*# sourceMappingURL=routing.css.map */

package/dist/routing.css.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tools/routing/reflection/ToolDebugOverlay.module.css"],"sourcesContent":["/* src/tools/routing/reflection/ToolDebugOverlay.module.css */\n.overlay {\n  position: absolute;\n  bottom: 12px;\n  right: 12px;\n  min-width: 180px;\n  padding: 8px 10px;\n  background: rgba(20, 20, 24, 0.86);\n  color: #eaeaea;\n  font: 11px/1.4 ui-monospace, \"SF Mono\", Menlo, monospace;\n  border: 1px solid rgba(255, 255, 255, 0.1);\n  border-radius: 4px;\n  pointer-events: none;\n  user-select: none;\n}\n\n.row {\n  display: flex;\n  justify-content: space-between;\n  gap: 12px;\n}\n\n.label {\n  color: #888;\n}\n\n.value {\n  color: #f5f5f5;\n}\n\n.empty {\n  color: #888;\n  font-style: italic;\n}\n"],"mappings":";AACA,CAAC;AACC,YAAU;AACV,UAAQ;AACR,SAAO;AACP,aAAW;AACX,WAAS,IAAI;AACb,cAAY,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;AAC7B,SAAO;AACP;AAAA,IAAM,IAAI,CAAC,IAAI,YAAY;AAAA,IAAE,SAAS;AAAA,IAAE,KAAK;AAAA,IAAE;AAC/C,UAAQ,IAAI,MAAM,KAAK,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;AACtC,iBAAe;AACf,kBAAgB;AAChB,eAAa;AACf;AAEA,CAAC;AACC,WAAS;AACT,mBAAiB;AACjB,OAAK;AACP;AAEA,CAAC;AACC,SAAO;AACT;AAEA,CAAC;AACC,SAAO;AACT;AAEA,CAAC;AACC,SAAO;AACP,cAAY;AACd;","names":[]}

package/dist/routing.d.ts

@@ -0,0 +1,14 @@
+export { N as ActionFn, Q as AffordanceHit, V as BeginSpec, X as Conflict, Y as EmptyHit, Z as HitResult, _ as ModifierRoute, $ as NodeHit, a0 as NodeRef, a1 as NodeRefHit, a2 as PhaseDef, a3 as RegistryEntry, a4 as Result, a5 as RouteEntry, a6 as RouteGesture, a7 as RoutePhase, a8 as RouteResolvedInfo, a9 as RouteTable, aa as ToolDebugOverlay, ab as ToolDebugOverlayProps, ac as ToolDef, f as ToolKeybinding, ad as ViewportPhaseDef, ae as ViewportToolDef, af as apply, ag as begin, ah as buildActionRegistry, ai as cancel, aj as claim, ak as commit, al as defineTool, am as defineViewportTool, an as findConflicts, ao as formatRouteResolved, ap as forwardActionTo, aq as hold, ar as none, as as resolveRoute, at as useToolDebugInfo } from './index-DZBYMsHI.js';
+export { ChannelRef, DescribeRouteOptions, GESTURE_DESCRIPTORS, GestureArgSpec, GestureDescriptor, GestureName, ModRequirement, ModifierCombo, 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, mods, parseRoute } from '@weasel-js/gestures';
+import './types-Cpb4hii1.js';
+import '@weasel-js/history';
+import './types-B6MMiodD.js';
+import 'react';
+import './view-DSQgxBJB.js';
+import './types-BjUi2vA-.js';
+import './types-B_-khFM0.js';
+import './fitViewToBounds-evGsnR8Q.js';
+import './DrawCommand-Dl0bXNfS.js';
+import './registerTexture-BzHTLhD9.js';
+import './types-BJ8_cyT7.js';
+import '@weasel-js/modes';

package/dist/routing.js

@@ -0,0 +1,4 @@
+export { GESTURE_DESCRIPTORS, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, ToolDebugOverlay, apply, begin, buildActionRegistry, cancel, canonicalModifiers, claim, collapseShiftPairs, commit, defineTool, defineViewportTool, describeRoute, describeRouteParts, findConflicts, formatPhaseAtom, formatRoute, formatRouteResolved, forwardActionTo, getGestureDescriptor, hold, isKnownGestureName, mods, none, parseRoute, resolveRoute, useToolDebugInfo } from './chunk-AM6ARSPN.js';
+import './chunk-PZ5AY32C.js';
+//# sourceMappingURL=routing.js.map
+//# sourceMappingURL=routing.js.map

package/dist/routing.js.map

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

package/dist/types-B6MMiodD.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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`.
+ */
+/** Command code: moveTo. */
+declare const PATH_M = 0;
+/** Command code: lineTo. */
+declare const PATH_L = 1;
+/** Command code: cubic bezier (`bezierCurveTo`). */
+declare const PATH_C = 2;
+/** Command code: quadratic bezier (`quadraticCurveTo`). */
+declare const PATH_Q = 3;
+/** Command code: close subpath. */
+declare const PATH_Z = 4;
+/** Float coords consumed by each command, indexed by command code. */
+declare const PATH_CMD_LENGTHS: readonly number[];
+/** 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;
+
+export { type Path as P, type RectPath as R, type PolygonPath as a, type PathFillRule as b, PATH_C as c, PATH_CMD_LENGTHS as d, PATH_L as e, PATH_M as f, PATH_Q as g, PATH_Z as h };