@weasel-js/ui 0.5.0 → 0.5.1

package/dist/components/CurveEditor/LayeredCurveEditor.d.ts

@@ -0,0 +1,40 @@
+import { type CSSProperties, type ReactNode } from 'react';
+import { type GridSettings, type AxesSettings } from '../Plot2D';
+import type { CurveLayer } from './layerTypes';
+export interface LayerBinding<S = unknown> {
+    layer: CurveLayer<S>;
+    state: S;
+}
+export interface LayeredCurveEditorProps {
+    /** Bottom-to-top render order: `layers[0]` paints first, `layers[N-1]`
+     *  paints on top. Hit-testing runs in reverse (topmost claim wins). */
+    layers: ReadonlyArray<LayerBinding<any>>;
+    /** Fires every frame during a gesture with the live in-flight state
+     *  for the layer that owns the gesture. */
+    onLayerChange(id: string, next: unknown): void;
+    /** Fires once per discrete user action (drag-end, one-shot insert,
+     *  delete) for the layer that produced the change. `prev` is the
+     *  layer's state at gesture start. */
+    onLayerCommit?(id: string, next: unknown, prev: unknown): void;
+    width: number;
+    height: number;
+    /** Model-space x range. Default [0, 1]. */
+    xRange?: readonly [number, number];
+    /** Model-space y range. Default [0, 1]. */
+    yRange?: readonly [number, number];
+    grid?: GridSettings | false | null;
+    axes?: AxesSettings | false | null;
+    /** Built-in undo/redo via Cmd/Ctrl+Z (Shift+Z or Y for redo) on the
+     *  focused SVG. Snapshots every layer's state on each commit; undo
+     *  fires `onLayerChange(id, prevState)` for each layer whose state
+     *  changed. Default `true`. */
+    history?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    /** Extra SVG content rendered behind all layers (under the lowest
+     *  layer but above grid/axes). Use this for static chrome that isn't
+     *  worth modeling as a layer. */
+    children?: ReactNode;
+}
+export declare function LayeredCurveEditor(props: LayeredCurveEditorProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LayeredCurveEditor.d.ts.map

package/dist/components/CurveEditor/LayeredCurveEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayeredCurveEditor.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/LayeredCurveEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAGlB,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAOnB,OAAO,KAAK,EACV,UAAU,EACX,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACvC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACrB,KAAK,EAAE,CAAC,CAAC;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC;2EACuE;IACvE,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;IAEzC;+CAC2C;IAC3C,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAE/C;;0CAEsC;IACtC,aAAa,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAE/D,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,IAAI,CAAC,EAAE,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC;IACnC,IAAI,CAAC,EAAE,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC;IAEnC;;;mCAG+B;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;IAEtB;;qCAEiC;IACjC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAmBD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,2CA0UhE"}

package/dist/components/CurveEditor/catmullRom.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Catmull-Rom spline sampling, parameterized by α.
+ *
+ * α = 0   → uniform parameterization (original Catmull-Rom). Fast, can
+ *           produce cusps and self-intersections at sharp 2D angles.
+ * α = 0.5 → centripetal (Yuksel/Schneider 2011). No cusps, no
+ *           self-intersection. The "safe default" for 2D.
+ * α = 1   → chordal. Smoother than uniform, different artifacts.
+ *
+ * `sampleCurve(...)` is the convenience alias for centripetal (α=0.5).
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Sample the Catmull-Rom segment between p1 and p2 at parameter
+ * t ∈ [0, 1]. p0 and p3 are the surrounding control points (use phantom
+ * reflection at endpoints — see sampleCatmullRom below).
+ *
+ * Returns p1 at t=0 and p2 at t=1. `alpha` controls parameterization.
+ */
+export declare function segmentSampleAt(p0: Point, p1: Point, p2: Point, p3: Point, t: number, alpha?: number): Point;
+/**
+ * Sample the whole curve through `anchors` using Catmull-Rom with the
+ * given α. Returns `(n-1) * samplesPerSegment + 1` points. Phantom
+ * endpoints by reflection so the first/last segments are tangent to
+ * the chord into/out of the endpoints. Returns `[]` for fewer than 2
+ * anchors.
+ */
+export declare function sampleCatmullRom(anchors: readonly Point[], samplesPerSegment: number, alpha?: number): Point[];
+/** Convenience alias for centripetal Catmull-Rom (α=0.5). The most
+ *  common choice; safe default for 2D paths. */
+export declare function sampleCurve(anchors: readonly Point[], samplesPerSegment: number): Point[];
+//# sourceMappingURL=catmullRom.d.ts.map

package/dist/components/CurveEditor/catmullRom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catmullRom.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/catmullRom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAQD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EACrD,KAAK,GAAE,MAAY,GAClB,KAAK,CA4BP;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,KAAK,EAAE,EACzB,iBAAiB,EAAE,MAAM,EACzB,KAAK,GAAE,MAAY,GAClB,KAAK,EAAE,CAoCT;AAED;gDACgD;AAChD,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,KAAK,EAAE,EACzB,iBAAiB,EAAE,MAAM,GACxB,KAAK,EAAE,CAET"}

package/dist/components/CurveEditor/createFunctionLayer.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Built-in function/curve layer for LayeredCurveEditor. Bundles the
+ * curve-render + anchor-render + drag/insert/delete gestures that were
+ * the entirety of the original `CurveEditor`. Multiple instances coexist
+ * by id; consumers can compose several to plot e.g. a primary function
+ * and a derived (read-only) curve on the same chart.
+ */
+import type { ReactNode } from 'react';
+import { type InterpolationMode } from './interpolation';
+import type { CurveLayer } from './layerTypes';
+export interface ControlPoint {
+    x: number;
+    y: number;
+    /** When true, this control point can't be moved or deleted by the
+     *  user. Render as a smaller diamond with locked styling. */
+    locked?: boolean;
+}
+export type CurveDomain = '1d' | '2d';
+export type EndpointMode = 'free' | 'pinned-x' | 'pinned-both';
+export type AddPointMode = 'click-curve' | 'click-empty' | 'never';
+export interface AnchorRenderProps {
+    point: ControlPoint;
+    index: number;
+    cx: number;
+    cy: number;
+    isActive: boolean;
+    isLocked: boolean;
+    isPinnedEndpoint: boolean;
+    isEndpoint: boolean;
+}
+export interface CurveSettings {
+}
+export interface FillSettings {
+    side: 'below' | 'above';
+    color?: string;
+}
+export interface FunctionLayerConfig {
+    /** Layer id; default `'function'`. Two instances on the same editor
+     *  must have distinct ids. */
+    id?: string;
+    domain?: CurveDomain;
+    endpoints?: EndpointMode;
+    interpolation?: InterpolationMode;
+    constrain?: 'none' | 'function';
+    addPointMode?: AddPointMode;
+    minPoints?: number;
+    maxPoints?: number;
+    curve?: CurveSettings | false | null;
+    fill?: FillSettings | false | null;
+    hideNonInteractive?: boolean;
+    renderAnchor?: (info: AnchorRenderProps) => ReactNode;
+    /** When false, the layer renders the curve+fill but doesn't render
+     *  anchors and doesn't accept pointer input. For derived read-only
+     *  curves (e.g. plotting f'(x) alongside f(x)). Default true. */
+    interactive?: boolean;
+    /** Override x clamp range for drags and pinned endpoints. Defaults
+     *  to the editor's modelRange x. Use this to constrain a layer to a
+     *  sub-range of the plot (e.g. a bevel curve occupying x ∈ [0, b]
+     *  while the editor's xRange is [0, halfWidth]). */
+    xClamp?: readonly [number, number];
+}
+export interface FunctionLayerState {
+    points: readonly ControlPoint[];
+    /** Layer-internal: the index of the anchor currently being dragged.
+     *  Cleared between gestures. Consumers treat the whole state as
+     *  opaque and round-trip it via onLayerChange. */
+    activeIndex: number | null;
+}
+export declare function createFunctionLayer(cfg?: FunctionLayerConfig): CurveLayer<FunctionLayerState>;
+/** Convenience: build a function-layer state from a points array. */
+export declare function functionLayerState(points: readonly ControlPoint[]): FunctionLayerState;
+//# sourceMappingURL=createFunctionLayer.d.ts.map

package/dist/components/CurveEditor/createFunctionLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFunctionLayer.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/createFunctionLayer.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAyB,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIhF,OAAO,KAAK,EACV,UAAU,EAEX,MAAM,cAAc,CAAC;AAItB,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV;iEAC6D;IAC7D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;AACtC,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,aAAa,CAAC;AAC/D,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,YAAY,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;CAE7B;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC;kCAC8B;IAC9B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,GAAG,KAAK,GAAG,IAAI,CAAC;IACrC,IAAI,CAAC,EAAE,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC;IACnC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,SAAS,CAAC;IACtD;;qEAEiE;IACjE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;wDAGoD;IACpD,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC;;sDAEkD;IAClD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAsDD,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,mBAAwB,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAkQjG;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,kBAAkB,CAEtF"}

package/dist/components/CurveEditor/hitTest.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Curve-specific hit tests. Generic coord transforms live in
+ * `../Plot2D/geometry`; what's here is curve-only (anchor / polyline
+ * proximity).
+ */
+import type { Point } from '../Plot2D/geometry';
+/**
+ * Nearest-anchor hit test. Anchors are already in plot/screen coords.
+ * Returns the index of the nearest anchor whose squared distance to
+ * the pointer is ≤ radius². Null if no anchor is within radius.
+ */
+export declare function hitTestAnchor(anchors: readonly Point[], pointer: Point, radius: number): {
+    index: number;
+} | null;
+/**
+ * Hit test against a per-segment sampled polyline. Each entry in
+ * `segments` is the sample list for one segment (inclusive of
+ * endpoints). Returns segment index + t (∈ [0, 1]) of the closest
+ * point on the polyline within radius. Null if nothing is in range.
+ *
+ * Distance is measured to the line-segment chords between adjacent
+ * samples, not just to the samples themselves — so sparse sampling
+ * still produces accurate hits along the chord.
+ */
+export declare function hitTestCurve(segments: readonly (readonly Point[])[], pointer: Point, radius: number): {
+    segIdx: number;
+    t: number;
+} | null;
+//# sourceMappingURL=hitTest.d.ts.map

package/dist/components/CurveEditor/hitTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitTest.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/hitTest.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,KAAK,EAAE,EACzB,OAAO,EAAE,KAAK,EACd,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAY1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,SAAS,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,EACvC,OAAO,EAAE,KAAK,EACd,MAAM,EAAE,MAAM,GACb;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA6BtC"}

package/dist/components/CurveEditor/index.d.ts

@@ -0,0 +1,7 @@
+export { CurveEditor, type CurveEditorProps, } from './CurveEditor';
+export { type ControlPoint, type CurveDomain, type EndpointMode, type AddPointMode, type FillSettings, type CurveSettings, type AnchorRenderProps, createFunctionLayer, functionLayerState, type FunctionLayerConfig, type FunctionLayerState, } from './createFunctionLayer';
+export { LayeredCurveEditor, type LayeredCurveEditorProps, type LayerBinding, } from './LayeredCurveEditor';
+export type { CurveLayer, LayerCtx, LayerRenderCtx, LayerHit, LayerGesture, LayerModifiers, EmptyDownArgs, ModelPoint, PlotPoint, } from './layerTypes';
+export { createSetCurveOp, type SetCurveAdapter, type CreateSetCurveOpArgs, } from './setCurveOp';
+export { sampleByInterpolation, type InterpolationMode, } from './interpolation';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/CurveEditor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,kBAAkB,EAClB,KAAK,uBAAuB,EAC5B,KAAK,YAAY,GAClB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,UAAU,EACV,QAAQ,EACR,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,aAAa,EACb,UAAU,EACV,SAAS,GACV,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,qBAAqB,EACrB,KAAK,iBAAiB,GACvB,MAAM,iBAAiB,CAAC"}

package/dist/components/CurveEditor/interpolation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Interpolation mode dispatcher for CurveEditor. The vocabulary of
+ * supported algorithms and the unified `sample(...)` entry point that
+ * picks the right one. All algorithms produce
+ * `(n-1) * samplesPerSegment + 1` points and pass through every
+ * anchor — CurveEditor is strictly interpolating, never approximating.
+ */
+import { type Point } from './catmullRom';
+/** Supported interpolation modes. All are interpolating (pass through
+ *  every anchor); the differences are in tangent computation and
+ *  parameterization. */
+export type InterpolationMode = 'linear' | 'catmull-rom' | 'catmull-rom-uniform' | 'catmull-rom-chordal' | 'monotone';
+/** Sample `anchors` using the chosen interpolation mode. */
+export declare function sampleByInterpolation(anchors: readonly Point[], samplesPerSegment: number, mode: InterpolationMode): Point[];
+//# sourceMappingURL=interpolation.d.ts.map

package/dist/components/CurveEditor/interpolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolation.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/interpolation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAoB,KAAK,KAAK,EAAE,MAAM,cAAc,CAAC;AAG5D;;wBAEwB;AACxB,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,aAAa,GACb,qBAAqB,GACrB,qBAAqB,GACrB,UAAU,CAAC;AA2Bf,4DAA4D;AAC5D,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,KAAK,EAAE,EACzB,iBAAiB,EAAE,MAAM,EACzB,IAAI,EAAE,iBAAiB,GACtB,KAAK,EAAE,CAcT"}

package/dist/components/CurveEditor/layerTypes.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Layered curve editor contract.
+ *
+ * A `CurveLayer` is a pure-value description of one composable layer
+ * inside `LayeredCurveEditor`. State lives outside the layer (held by
+ * the consumer); the layer only provides render + hit-test + gesture
+ * starters. This lets the editor coordinate cross-layer reactivity —
+ * when one layer's gesture updates its state, the consumer can update
+ * other layers' states in the same render, and the in-flight gesture
+ * keeps reading the latest state.
+ */
+import type { ReactNode } from 'react';
+import type { Point as PlotPoint, ModelRange } from '../Plot2D/geometry';
+/** Convenience aliases — both are `{ x, y }` but with different units. */
+export type ModelPoint = PlotPoint;
+export type { PlotPoint };
+export interface LayerModifiers {
+    shift: boolean;
+    alt: boolean;
+    meta: boolean;
+    ctrl: boolean;
+}
+/** Read-only context passed to every layer hook. Layers use this to
+ *  convert between plot (SVG-pixel) and model (data) coordinates. */
+export interface LayerCtx {
+    readonly modelRange: ModelRange;
+    readonly plotSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    toPlot(p: ModelPoint): PlotPoint;
+    toModel(p: PlotPoint): ModelPoint;
+    readonly modifiers: LayerModifiers;
+}
+export interface LayerRenderCtx extends LayerCtx {
+    /** True when this layer owns the currently-active gesture. Useful for
+     *  surfacing "active anchor" visuals without threading the index. */
+    readonly isActive: boolean;
+}
+/** Layer-private payload returned from `hitTest`. The editor doesn't
+ *  read it — it just round-trips it back into `onPointerDown`. */
+export interface LayerHit {
+    /** Layer-local discriminator (e.g. `'anchor'`, `'curve'`). */
+    kind: string;
+    payload?: unknown;
+}
+/** A live gesture installed by a successful `onPointerDown`. The editor
+ *  routes window-level pointermove/up/cancel into these callbacks until
+ *  the gesture ends.
+ *
+ *  `onMove` is pure: it takes the layer's *current* state (which may
+ *  have been updated by upstream re-renders since the gesture started)
+ *  and returns the next state. The editor publishes that next state via
+ *  `onLayerChange`. */
+export interface LayerGesture<S> {
+    onMove(state: S, model: ModelPoint, e: PointerEvent, ctx: LayerCtx): S;
+    /** Pointerup. Return the final state. The editor uses this as the
+     *  `next` value passed to `onLayerCommit`. Default: return state
+     *  unchanged. */
+    onCommit?(state: S, ctx: LayerCtx): S;
+    /** Pointercancel. Return the state to restore (usually the
+     *  pre-gesture snapshot). Default: return state unchanged. */
+    onCancel?(state: S, ctx: LayerCtx): S;
+}
+/** Pure-value layer description. Multiple instances of the same factory
+ *  output (e.g. two `createFunctionLayer` results) coexist by `id`. */
+export interface CurveLayer<S> {
+    /** Stable identifier — used as the key when the editor calls back
+     *  with state updates. Must be unique within an editor instance. */
+    readonly id: string;
+    /** Render the layer's visuals as SVG children inside the editor's
+     *  Plot2D. Coordinates the layer renders into are plot-space. */
+    render(state: S, ctx: LayerRenderCtx): ReactNode;
+    /** Plot-space hit test. Return null to pass the point to the next
+     *  layer (top-to-bottom). Topmost-claimed wins. */
+    hitTest?(state: S, plot: PlotPoint, ctx: LayerCtx): LayerHit | null;
+    /** A positive hit-test starts a gesture, absorbs the click with no
+     *  gesture by returning void, or publishes a one-shot edit via
+     *  `extra.commit(next)` and returns void (e.g. shift-click delete). */
+    onPointerDown?(state: S, hit: LayerHit, e: PointerEvent, ctx: LayerCtx, extra: EmptyDownArgs<S>): LayerGesture<S> | void;
+    /** Pointerdown landed where no layer claimed a hit. Layers get a
+     *  turn top-to-bottom; first non-void return wins. Either start a
+     *  gesture or commit a one-shot edit (return void after publishing
+     *  state via the editor — see `EmptyDownArgs.commit`). */
+    onEmptyPointerDown?(state: S, model: ModelPoint, e: PointerEvent, ctx: LayerCtx, extra: EmptyDownArgs<S>): LayerGesture<S> | void;
+    /** Keyboard while the editor has focus. Top-to-bottom; call
+     *  `e.preventDefault()` to stop propagation. */
+    onKeyDown?(state: S, e: KeyboardEvent, ctx: LayerCtx): void;
+}
+/** Helpers handed to `onPointerDown` and `onEmptyPointerDown` so a
+ *  layer can publish a one-shot edit (shift-click delete, empty-click
+ *  insert) without a drag gesture, and read the click's plot+model
+ *  coords without re-deriving them from the DOM event. */
+export interface EmptyDownArgs<S> {
+    /** Pointer in plot space. */
+    readonly plot: PlotPoint;
+    /** Pointer in model space. */
+    readonly model: ModelPoint;
+    /** Publish a state update *and* mark the action as committed. Use
+     *  this when the click results in an immediate, undoable edit. */
+    commit(next: S): void;
+}
+//# sourceMappingURL=layerTypes.d.ts.map

package/dist/components/CurveEditor/layerTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layerTypes.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/layerTypes.ts"],"names":[],"mappings":"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"}

package/dist/components/CurveEditor/monotone.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Monotone cubic interpolation (Fritsch-Carlson / Steffen variant).
+ *
+ * Passes through every anchor and guarantees the curve never
+ * overshoots `min(neighbors)` / `max(neighbors)` along either axis.
+ * The right choice for animation timing curves (no anticipation) or
+ * audio envelopes (no out-of-range values).
+ *
+ * Parameterized by index — works for both 1D (function-shaped) and
+ * 2D (parametric) anchor sequences. The x and y coordinates are
+ * interpolated independently as functions of the anchor index.
+ *
+ * Reference: Fritsch & Carlson 1980, "Monotone piecewise cubic
+ * interpolation." Steffen's 1990 refinement is conceptually the same;
+ * we use a min-clamp variant that's monotonicity-preserving by
+ * construction.
+ */
+import type { Point } from './catmullRom';
+/**
+ * Sample the monotone-cubic curve through `anchors`. Returns
+ * `(n-1) * samplesPerSegment + 1` points (same shape as
+ * `sampleCatmullRom`). `[]` for fewer than 2 anchors.
+ */
+export declare function sampleMonotone(anchors: readonly Point[], samplesPerSegment: number): Point[];
+//# sourceMappingURL=monotone.d.ts.map

package/dist/components/CurveEditor/monotone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monotone.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/monotone.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAkD1C;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,KAAK,EAAE,EACzB,iBAAiB,EAAE,MAAM,GACxB,KAAK,EAAE,CAwBT"}

package/dist/components/CurveEditor/setCurveOp.d.ts

@@ -0,0 +1,35 @@
+import type { Op } from '@weasel-js/core';
+import type { ControlPoint } from './CurveEditor';
+/**
+ * The adapter contract for {@link createSetCurveOp}. Consumers wire
+ * this to whatever state container holds the curve's value — typically
+ * a small callback that calls a React state setter or dispatches a
+ * Redux/Zustand action.
+ */
+export interface SetCurveAdapter {
+    setValue(id: string, next: readonly ControlPoint[]): void;
+}
+export interface CreateSetCurveOpArgs {
+    /** Stable id the consumer uses for this curve. Used so a single
+     *  adapter can handle multiple curves; the op's apply routes by id. */
+    id: string;
+    from: readonly ControlPoint[];
+    to: readonly ControlPoint[];
+    label?: string;
+    coalesceKey?: string;
+}
+/**
+ * Op factory for editing a CurveEditor's value through weasel-history.
+ *
+ *     history.applyOps(
+ *       [createSetCurveOp({ id: 'easing', from, to, label: 'Edit easing' })],
+ *       'Edit easing',
+ *     );
+ *
+ * The op's `apply(adapter)` calls `adapter.setValue(id, to)`. `invert()`
+ * returns a mirror op with `from`/`to` swapped. When `from` and `to`
+ * are structurally equal, `apply` returns `false` so history can skip
+ * the entry — same convention as `createSetPathOp`.
+ */
+export declare function createSetCurveOp(args: CreateSetCurveOpArgs): Op;
+//# sourceMappingURL=setCurveOp.d.ts.map

package/dist/components/CurveEditor/setCurveOp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setCurveOp.d.ts","sourceRoot":"","sources":["../../../src/components/CurveEditor/setCurveOp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,YAAY,EAAE,GAAG,IAAI,CAAC;CAC3D;AAED,MAAM,WAAW,oBAAoB;IACnC;2EACuE;IACvE,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC;IAC9B,EAAE,EAAE,SAAS,YAAY,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,EAAE,CAgB/D"}

package/dist/components/DataGrid/DataGrid.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from 'react';
+export interface DataGridColumn<Row> {
+    id: string;
+    header: ReactNode;
+    /** Pull a sortable value from the row. Defaults to `(row as any)[column.id]`. */
+    accessor?: (row: Row) => string | number | null | undefined;
+    /** Render the cell. Defaults to `String(accessor(row) ?? '')`. */
+    render?: (row: Row) => ReactNode;
+    /** Default true. Set false to suppress the sort affordance on this column. */
+    sortable?: boolean;
+    /** Optional CSS class on every <td> in this column. */
+    className?: string;
+}
+export interface DataGridProps<Row extends {
+    id: string;
+}> {
+    rows: readonly Row[];
+    columns: readonly DataGridColumn<Row>[];
+    /** Initial sort. Omit for unsorted (rows render in input order). */
+    defaultSort?: {
+        columnId: string;
+        direction: 'asc' | 'desc';
+    };
+    /** Enable drag handles in a leading column. Receives the reorder spec
+     *  (the existing `useReorderDragList` semantics — see weasel-ui). */
+    onReorder?: (ids: string[], targetIndex: number) => void;
+    /** Empty-state row text. Default `'—'`. */
+    empty?: ReactNode;
+    className?: string;
+}
+export declare function DataGrid<Row extends {
+    id: string;
+}>(props: DataGridProps<Row>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DataGrid.d.ts.map

package/dist/components/DataGrid/DataGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataGrid.d.ts","sourceRoot":"","sources":["../../../src/components/DataGrid/DataGrid.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,MAAM,WAAW,cAAc,CAAC,GAAG;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,CAAC;IAClB,iFAAiF;IACjF,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC5D,kEAAkE;IAClE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,SAAS,CAAC;IACjC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa,CAAC,GAAG,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE;IACvD,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;IACrB,OAAO,EAAE,SAAS,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;IACxC,oEAAoE;IACpE,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,KAAK,GAAG,MAAM,CAAA;KAAE,CAAC;IAC9D;yEACqE;IACrE,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACzD,2CAA2C;IAC3C,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,wBAAgB,QAAQ,CAAC,GAAG,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,2CAmH7E"}

package/dist/components/DataGrid/index.d.ts

@@ -0,0 +1,3 @@
+export { DataGrid } from './DataGrid';
+export type { DataGridColumn, DataGridProps } from './DataGrid';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/DataGrid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/DataGrid/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/components/Dialog/Dialog.d.ts

@@ -0,0 +1,29 @@
+import type { ReactNode } from 'react';
+import { type ModalOverlayProps, type DialogProps as RACDialogProps } from 'react-aria-components';
+export type DialogProps = Omit<ModalOverlayProps, 'children' | 'className'> & {
+    /** Heading rendered in the dialog's default header. Omit when supplying
+     *  a custom `header` slot via children. */
+    title?: ReactNode;
+    /** Show the built-in close button. Defaults to true when `onOpenChange`
+     *  is wired so the user has an escape hatch. */
+    showCloseButton?: boolean;
+    /** Body content. */
+    children?: ReactNode;
+    /** Footer slot — typically action buttons. */
+    footer?: ReactNode;
+    /** ARIA role. Defaults to `dialog`. Use `alertdialog` for confirms. */
+    role?: RACDialogProps['role'];
+    /** Class applied to the modal box (inside the overlay). */
+    className?: string;
+};
+/**
+ * Modal dialog wrapping React Aria. Supplies a default header (title +
+ * close), scrollable body, and footer slot. Pass `isOpen` + `onOpenChange`
+ * for controlled visibility, or omit both and use a `<DialogTrigger>` from
+ * `react-aria-components` upstream of this component.
+ *
+ * Escape, click-outside, focus trap, and scroll lock all come from the
+ * underlying primitives.
+ */
+export declare function Dialog(props: DialogProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Dialog.d.ts.map

package/dist/components/Dialog/Dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dialog.d.ts","sourceRoot":"","sources":["../../../src/components/Dialog/Dialog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAKL,KAAK,iBAAiB,EACtB,KAAK,WAAW,IAAI,cAAc,EACnC,MAAM,uBAAuB,CAAC;AAG/B,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,WAAW,CAAC,GAAG;IAC5E;+CAC2C;IAC3C,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;oDACgD;IAChD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,oBAAoB;IACpB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,uEAAuE;IACvE,IAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAC9B,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,2CA8CxC"}

package/dist/components/Dialog/index.d.ts

@@ -0,0 +1,3 @@
+export { Dialog } from './Dialog';
+export type { DialogProps } from './Dialog';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Dialog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Dialog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/components/Field/Field.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+export type FieldOrientation = 'stacked' | 'row';
+export type FieldProps = {
+    orientation?: FieldOrientation;
+    className?: string;
+    children?: ReactNode;
+};
+/**
+ * Layout primitive that arranges a label, control, hint, and error in the
+ * canonical weasel-ui form-row shape. The control itself owns its semantics
+ * (RAC `TextField`, `Checkbox`, etc.); this just paints the layout.
+ *
+ * Most users will instead reach for `Input` / `Checkbox` / `Switch`, which
+ * compose Field internally. Use Field directly when you need a custom
+ * control to sit in the same visual rhythm.
+ */
+export declare function Field({ orientation, className, children }: FieldProps): import("react/jsx-runtime").JSX.Element;
+export declare const fieldClasses: {
+    root: string;
+    row: string;
+    label: string;
+    hint: string;
+    error: string;
+};
+//# sourceMappingURL=Field.d.ts.map

package/dist/components/Field/Field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Field.d.ts","sourceRoot":"","sources":["../../../src/components/Field/Field.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,KAAK,CAAC;AAEjD,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,EAAE,WAAuB,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,UAAU,2CAGjF;AAED,eAAO,MAAM,YAAY;;;;;;CAMxB,CAAC"}

package/dist/components/Field/index.d.ts

@@ -0,0 +1,3 @@
+export { Field, fieldClasses } from './Field';
+export type { FieldProps, FieldOrientation } from './Field';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Field/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Field/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC9C,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC"}

package/dist/components/Input/Input.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from 'react';
+import { type TextFieldProps as RACTextFieldProps, type ValidationResult } from 'react-aria-components';
+export type InputProps = Omit<RACTextFieldProps, 'children' | 'className'> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode | ((v: ValidationResult) => ReactNode);
+    placeholder?: string;
+    leadingAdornment?: ReactNode;
+    trailingAdornment?: ReactNode;
+    className?: string;
+};
+/**
+ * Single-line text input wrapping React Aria's TextField. Supplies a
+ * default skin against the `--wzl-*` token system, and exposes the
+ * familiar label / description / errorMessage / adornment slot shape.
+ *
+ * `ref` forwards to the underlying `<input>`.
+ */
+export declare const Input: import("react").ForwardRefExoticComponent<Omit<RACTextFieldProps, "children" | "className"> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode | ((v: ValidationResult) => ReactNode);
+    placeholder?: string;
+    leadingAdornment?: ReactNode;
+    trailingAdornment?: ReactNode;
+    className?: string;
+} & import("react").RefAttributes<HTMLInputElement>>;
+//# sourceMappingURL=Input.d.ts.map

package/dist/components/Input/Input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input.d.ts","sourceRoot":"","sources":["../../../src/components/Input/Input.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,SAAS,EAAY,MAAM,OAAO,CAAC;AAC7D,OAAO,EAML,KAAK,cAAc,IAAI,iBAAiB,EACxC,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAI/B,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,WAAW,CAAC,GAAG;IAC3E,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,YAAY,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,EAAE,gBAAgB,KAAK,SAAS,CAAC,CAAC;IAChE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,SAAS,CAAC;IAC7B,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,KAAK;YAhBR,SAAS;kBACH,SAAS;mBACR,SAAS,GAAG,CAAC,CAAC,CAAC,EAAE,gBAAgB,KAAK,SAAS,CAAC;kBACjD,MAAM;uBACD,SAAS;wBACR,SAAS;gBACjB,MAAM;oDAyClB,CAAC"}

package/dist/components/Input/index.d.ts

@@ -0,0 +1,3 @@
+export { Input } from './Input';
+export type { InputProps } from './Input';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Input/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Input/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/components/Keycaps/Keycap.d.ts

@@ -0,0 +1,34 @@
+import type { CSSProperties } from 'react';
+export type KeycapKind = 'modifier' | 'wide' | 'square';
+export declare function inferKeycapKind(label: string): KeycapKind;
+export type KeyCapVariant = 'default' | 'minimal';
+export interface KeyCapProps {
+    /** Glyph rendered in the chip (modifier or key). */
+    label: string;
+    /** Marks the chip as not required to trigger the action. In the default
+     *  variant the chip face inverts (dark face / light glyph) for
+     *  emphasis. In the `'minimal'` variant the chip's border becomes
+     *  dotted to read as "may be held, but isn't required." */
+    inverted?: boolean;
+    /** Visual style. `'default'` (default) renders a filled chip; `'minimal'`
+     *  renders an unfilled chip whose border and legend are `currentColor`
+     *  — useful inline in colored prose / next to colored badges where the
+     *  chip should take the surrounding text color. */
+    variant?: KeyCapVariant;
+    className?: string;
+    /** Optional inline style. Useful for one-off width overrides (e.g.
+     *  building a keyboard-layout where the space bar spans several
+     *  standard-key widths). The component sets no inline styles of its
+     *  own — everything else comes from the CSS module. */
+    style?: CSSProperties;
+    /** Override the chip's font-family. Accepts any CSS font-family
+     *  string. When omitted, the chip inherits from the design-system
+     *  UI font token (`--wzl-font-ui`). Useful for one-off cases where
+     *  a different face is desired — though the canonical move is to
+     *  override the CSS variable at the consumer's scope, not the prop. */
+    font?: string;
+}
+/** Single bordered keycap chip for one glyph (modifier or key). Use
+ *  `KeySequence` to render a full shortcut. */
+export declare function KeyCap({ label, inverted, variant, className, style, font }: KeyCapProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Keycap.d.ts.map

package/dist/components/Keycaps/Keycap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Keycap.d.ts","sourceRoot":"","sources":["../../../src/components/Keycaps/Keycap.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAM3C,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAExD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAKzD;AAED,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,SAAS,CAAC;AAElD,MAAM,WAAW,WAAW;IAC1B,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd;;;+DAG2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;uDAGmD;IACnD,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;2DAGuD;IACvD,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB;;;;2EAIuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;+CAC+C;AAC/C,wBAAgB,MAAM,CAAC,EAAE,KAAK,EAAE,QAAgB,EAAE,OAAmB,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,WAAW,2CAa3G"}