@kitlangton/knobs 0.0.0-stage → 0.1.0

package/dist/types/panel/die.d.ts

@@ -0,0 +1,121 @@
+import { Spring, type SpringValue } from "../core/spring.js";
+export declare const DIE: {
+    readonly half: number;
+    readonly round: number;
+    readonly pip: 12;
+};
+/** Pip centres per face value, relative to the face centre, in icon units (y down). */
+export declare const PIPS: Record<number, readonly (readonly [number, number])[]>;
+type V3 = readonly [number, number, number];
+/**
+ * Faces: value, the cube rotation that brings it to the front, and its outward normal and in-plane
+ * axes in cube space (the front face rotated by the inverse turn). Opposites sum to 7.
+ */
+export declare const FACES: {
+    value: 3 | 1 | 2 | 4 | 5 | 6;
+    front: readonly [0 | 90 | -90, 0 | 180 | 90 | -90];
+    n: V3;
+    u: V3;
+    v: V3;
+}[];
+export interface DieLook {
+    /** Eye distance in icon sizes at full spin (the resting die is seen orthographically). */
+    readonly perspective: number;
+    /** How far a spinning die rises towards the eye, in icon sizes, at full spin. */
+    readonly lift: number;
+    /** Degrees from a face where the inked bevel begins (atan ½ ≈ 26.6° is Phosphor's outline). */
+    readonly bevel: number;
+    /** Face fill while spinning: ambient and lit (Lambert) parts. */
+    readonly fill: number;
+    readonly shade: number;
+}
+export declare const DIE_LOOK: DieLook;
+export interface DieSpin {
+    readonly spring: SpringValue;
+    /** Extra whole turns per roll. */
+    readonly turns: number;
+}
+export declare const DIE_SPIN: DieSpin;
+/**
+ * The box around a die of `size` px, in sizes: room for the corners while it tumbles and lifts
+ * (they reach 0.6 of a size out at the default look), so it overflows its button's round wash
+ * rather than clipping to it. Past `DIE_FEATHER` of the way out it fades, so a die tuned to lift
+ * further never meets a hard edge.
+ */
+export declare const DIE_BOX = 2;
+export declare const DIE_FEATHER = 0.75;
+export declare const dieBox: (size: number) => number;
+/** How much of the die shows `r` px from its centre: all of it, fading out at the box's edge. */
+export declare function dieFeather(size: number, r: number): number;
+/** Supersamples per axis: dense at icon sizes, cheaper when large. */
+export declare const dieSamples: (size: number) => 3 | 6;
+export declare class DieMotion {
+    readonly rx: Spring;
+    readonly ry: Spring;
+    value: number;
+    turns: number;
+    constructor(spin?: DieSpin);
+    tune({ spring, turns }: DieSpin): void;
+    /** Tumble to a different face (or `to`) from wherever it is now. */
+    roll(to?: number, random?: () => number): 3 | 1 | 2 | 4 | 5 | 6;
+    /** A quarter turn onto a neighbouring face: a nudge rather than a roll. */
+    nudge(random?: () => number): 3 | 1 | 2 | 4 | 5 | 6;
+    /** A quarter turn sideways (`dir` +1 rolls it rightwards): a die rolled along under the fingers. */
+    turn(dir: -1 | 1): number;
+    snapTo(value: number): void;
+    /** Advance; returns the orientation (degrees) and spin energy 0…1 for lift and shading. */
+    step(dt: number): DieView;
+    get resting(): boolean;
+}
+export interface DieView {
+    readonly rx: number;
+    readonly ry: number;
+    readonly energy: number;
+}
+/** The face a cube turned `rx`, `ry` (degrees) shows the viewer. */
+export declare function frontFace(rx: number, ry: number): 3 | 1 | 2 | 4 | 5 | 6;
+/** Light direction for the spin shading (towards the viewer, from the upper left; y down). */
+export declare const DIE_LIGHT: V3;
+/**
+ * Traces one ray through the pixel offset (`x`, `y`) px from the die's centre and returns
+ * ink + fill coverage (0…1), or `MISS`. Mirrors `die_trace` in die.wgsl.ts step for step.
+ */
+export declare function dieTracer(size: number, view: DieView, look: DieLook): (x: number, y: number) => number;
+/**
+ * The DOM die: a canvas traced in JS. Its backing store is whole device pixels and `render` takes
+ * the die centre in those pixels, so the caller can land the canvas on the pixel grid (no
+ * resampling blur). Each pixel is traced 2×2; only pixels whose samples disagree (an edge, a pip)
+ * are refined at `dieSamples` × `dieSamples`.
+ */
+export declare function createDieCanvas(doc: Document, size: number): {
+    canvas: HTMLCanvasElement;
+    /** Backing size (device px) for a given ratio; the CSS size is this over the ratio. */
+    pixels: (dpr: number) => number;
+    render(view: DieView, look: DieLook, rgba: readonly [number, number, number, number], dpr: number, centre: readonly [number, number]): void;
+};
+/** Icon size of the header die (px), matching the other header icons. */
+export declare const HEADER_DIE = 14;
+/** A group's die, beside its reset icon. */
+export declare const GROUP_DIE = 13;
+/**
+ * A die button's icon. It is always the traced die, rolling or at rest, so nothing swaps shape
+ * when a roll starts or lands. In the DOM it is a canvas laid on whole device pixels and re-traced
+ * when its colour changes (hover, focus, theme) or the zoom does; in GPU mode the canvas is skipped
+ * and the renderer traces `view` itself, with `onFrame` waking it.
+ */
+export declare function createHeaderDie(doc: Document, onFrame: () => void, size?: number): {
+    node: HTMLSpanElement;
+    size: number;
+    /** Tumble to another face; `nudge` turns a quarter onto a neighbour instead (Mutate). */
+    roll(nudge?: boolean): void;
+    /** A quarter turn sideways with a pan (`dir` +1 rightwards). */
+    turn(dir: -1 | 1): void;
+    /** Re-trace now (e.g. after the panel moved or switched renderer). */
+    repaint: () => void;
+    readonly view: DieView;
+    readonly value: number;
+    readonly rolling: boolean;
+    dispose(): void;
+};
+export type HeaderDie = ReturnType<typeof createHeaderDie>;
+export {};

package/dist/types/panel/editors.d.ts

@@ -0,0 +1,159 @@
+import { type Oklch } from "../core/color.js";
+import { type ColorField, type EasingField, type Knob, type PointField, type SpringField, type Value } from "../core/schema.js";
+import { type SpringValue } from "../core/spring.js";
+import type { GpuExpander, GpuRowBinding, GpuStrip, RowWave } from "./gpu/renderer.js";
+import { type Slider } from "./slider.js";
+/** What a row needs from the panel. */
+export interface RowContext<F> {
+    readonly doc: Document;
+    readonly key: string;
+    readonly display: string;
+    readonly field: F;
+    readonly wave: RowWave;
+    get(): Value;
+    set(value: unknown, options?: {
+        coalesce?: boolean;
+    }): void;
+    isModified(): boolean;
+    wake(): void;
+    /** Opens a disclosure row's editor at once, as it was before a reload. */
+    readonly expanded?: boolean;
+    /** A flat spring's two number fields: their ranges, labels and units replace the defaults. */
+    readonly parts?: {
+        readonly duration: Knob;
+        readonly bounce: Knob;
+    };
+    onExpand?(open: boolean): void;
+}
+/** A slider inside a compound row, adjusted by the panel's arrow keys like a knob row. */
+export interface SubTrack {
+    readonly slider: Slider;
+    readonly field: Knob;
+    get(): number;
+    set(value: number): void;
+}
+export interface EditorRow {
+    readonly row: HTMLElement;
+    readonly labelEl: HTMLElement;
+    /** Where the row's ↑↓ stop lands. */
+    readonly input: HTMLElement;
+    /** Every ↑↓ stop in the row, in order (an open editor's parts follow its head). */
+    stops(): HTMLElement[];
+    /**
+     * `instant` places the value without motion (a different item arrived); `mixed` shows it as
+     * indeterminate (a multi-selection whose items differ).
+     */
+    update(value: Value, delay: number, instant?: boolean, mixed?: boolean): void;
+    /** Reads what `update` will, ahead of a batch's writes (see `Slider.prime`). */
+    prime?(): void;
+    /** A flat spring's halves changed range or label (see `RowContext.parts`). */
+    retune?(parts: {
+        readonly duration: Knob;
+        readonly bounce: Knob;
+    }): void;
+    dispose(): void;
+    readonly tracks: readonly SubTrack[];
+    readonly gpu: readonly GpuRowBinding[];
+}
+export declare const reducedMotion: (doc: Document) => boolean;
+export declare const rgbCss: (rgb: readonly number[]) => string;
+export declare const pathOf: (pts: readonly number[]) => string;
+export declare const visible: (node: HTMLElement) => boolean;
+/** Applies a placement, skipping the transition when it's the first one or a resize. */
+export declare function place(nodes: readonly (HTMLElement | SVGElement)[], instant: boolean, apply: () => void): void;
+export declare function setPath(path: SVGPathElement, pts: readonly number[]): void;
+/** One undo step per gesture: the first change that lands records history, the rest fold in. */
+export declare function gesture(c: RowContext<unknown>): {
+    start(): void;
+    set(value: unknown): void;
+};
+export declare function factory(doc: Document): {
+    el: <K extends keyof HTMLElementTagNameMap>(tag: K, cls?: string, text?: string) => HTMLElementTagNameMap[K];
+    svg: <K extends keyof SVGElementTagNameMap>(tag: K, cls?: string) => SVGElementTagNameMap[K];
+};
+export declare const plainKey: (event: KeyboardEvent) => boolean;
+/** A size kept current by a ResizeObserver, so layout reads stay out of the frame loop. */
+export declare function measure(node: Element, onResize: () => void): {
+    w: number;
+    h: number;
+    disconnect: () => void;
+};
+export declare function expander(c: RowContext<unknown>, summary: Node[], body: Node[]): {
+    row: HTMLDivElement;
+    head: HTMLDivElement;
+    label: HTMLSpanElement;
+    body: HTMLDivElement;
+    isOpen: () => boolean;
+    gpu: GpuExpander;
+};
+interface StripOptions {
+    label: string;
+    aria: string;
+    min: number;
+    max: number;
+    step: number;
+    format(value: number): string;
+    set(value: number): void;
+    start(): void;
+}
+/** A scrub strip: a capsule track (painted by its row) with a ring thumb and a readout. */
+export declare function strip(c: RowContext<unknown>, o: StripOptions): {
+    line: HTMLDivElement;
+    track: HTMLDivElement;
+    thumb: HTMLElement;
+    gpu: GpuStrip;
+    update(value: number, text?: string): void;
+    paint(key: string, fn: (ratio: number) => string): void;
+    dispose: () => void;
+};
+/** The step response over a fixed 1.2 s window in a w×h box, as x,y pairs (px). */
+export declare function springCurve(value: SpringValue, w: number, h: number, pad?: number, padX?: number): number[];
+/** Duration and bounce as two sliders beside the curve they make; a dot runs the curve on change. */
+export declare function springRow(c: RowContext<SpringField>): EditorRow;
+/**
+ * Hue, relative chroma (0…maxC) and lightness strips for one colour: a colour row's body, and a
+ * gradient's editor for its selected stop. `commit` receives each change as OKLCH.
+ */
+export declare function colorStrips(c: RowContext<unknown>, o: {
+    aria: string;
+    start(): void;
+    commit(color: Oklch): void;
+}): {
+    body: HTMLDivElement;
+    strips: {
+        line: HTMLDivElement;
+        track: HTMLDivElement;
+        thumb: HTMLElement;
+        gpu: GpuStrip;
+        update(value: number, text?: string): void;
+        paint(key: string, fn: (ratio: number) => string): void;
+        dispose: () => void;
+    }[];
+    send: (patch: {
+        l?: number;
+        r?: number;
+        h?: number;
+    }) => void;
+    color: () => Oklch;
+    dragging: () => boolean;
+    /** Shows `color` (a new colour, or the same one after an edit); `mixed` dashes the readouts. */
+    show(color: Oklch, mixed?: boolean, fresh?: boolean): string;
+    dispose(): void;
+};
+/** OKLCH: a swatch and hex in the head; hue, relative chroma (0…maxC) and lightness strips in the body. */
+export declare function colorRow(c: RowContext<ColorField>): EditorRow;
+/** A 2D pad with crosshair guides, the default marked, and a puck that arrows and drags move. */
+export declare function pointRow(c: RowContext<PointField>): EditorRow;
+/**
+ * A sideways pan on a row's head steps through its presets like a menu, a tick each, as one undo
+ * step; past either end `nudged` (the head's mini strip or curve) gives a little.
+ */
+export declare function panPresets(c: RowContext<unknown>, head: HTMLElement, nudged: HTMLElement | SVGElement, o: {
+    readonly count: number;
+    /** The preset showing, or -1. */
+    at(): number;
+    choose(i: number, coalesce: boolean): void;
+}): void;
+/** A mini curve in the head; an editor with two handles and named chips in the body. */
+export declare function easingRow(c: RowContext<EasingField>): EditorRow;
+export {};

package/dist/types/panel/folds.d.ts

@@ -0,0 +1,14 @@
+import { type StoragePort } from "../core/storage.js";
+/** What a page remembers folded or open: its sections and its group cards. */
+export type FoldKind = "sections" | "groups";
+export interface FoldMemory {
+    /** What the user last chose for it, if anything. */
+    get(kind: FoldKind, id: string): boolean | undefined;
+    set(kind: FoldKind, id: string, folded: boolean): void;
+}
+/**
+ * A page's folds, kept under `knobs:<id>:folds:v1` in `storage` as
+ * `{ sections: Record<string, boolean>, groups: Record<string, boolean> }`, and nothing else (no
+ * values, locks or variants). `null` storage remembers nothing.
+ */
+export declare function foldMemory(id: string, storage: () => StoragePort | null): FoldMemory;

package/dist/types/panel/give.d.ts

@@ -0,0 +1,73 @@
+/** The most a control gives past an end (px). */
+export declare const GIVE = 6;
+/** The give `over` px of push past an end makes: 1:1 at first, never reaching `max`. */
+export declare const rubber: (over: number, max?: number) => number;
+/** The push (px) that makes `give` (`rubber`'s inverse). */
+export declare const unrubber: (give: number, max?: number) => number;
+/** A position (px) between two ends, and how far it gives past one of them. */
+export interface Band {
+    readonly at: number;
+    readonly give: number;
+}
+/**
+ * Moves `from.at` by `d` px within [lo, hi]. Past an end the rest of the push stretches the give;
+ * travel back takes the give up first, 1:1, and moves on with what's left.
+ */
+export declare function band(from: Band, d: number, lo: number, hi: number, max?: number): Band;
+/** A pan counted in whole steps: travel (px) toward the next one, and any give past an end. */
+export interface Steps {
+    readonly travel: number;
+    readonly give: number;
+}
+/**
+ * Adds `d` px of pan to `from`, a step every `size` px. `room` is how many steps there are each
+ * way (down, up) before this pan: once a way has none left, travel that way stretches the give.
+ * Returns the state and the steps to take (signed).
+ */
+export declare function stepBand(from: Steps, d: number, size: number, room: readonly [number, number], max?: number): {
+    readonly next: Steps;
+    readonly steps: number;
+};
+/** Px of pan per item when a pan steps through a list (a menu's choices, a ramp's presets). */
+export declare const LIST_STEP = 28;
+/**
+ * Where a pan through `count` items lands from `at` (-1: none of them, so the first step picks an
+ * end), and the state it leaves; `index` is undefined while it stays put.
+ */
+export declare function stepList(from: Steps, d: number, at: number, count: number, size?: number): {
+    next: Steps;
+    index: number | undefined;
+};
+/** Whether a move went from no give to some: the moment to tick. */
+export declare const stretched: (before: number, after: number) => boolean;
+/** The fingers' speed (px/ms, signed) over their last `window` ms of moves before a lift. */
+export declare function speedOf(moves: readonly {
+    readonly t: number;
+    readonly d: number;
+}[], window?: number): number;
+/** How many steps a lift at `speed` (px/ms) carries on for: none from a still hand, three at most. */
+export declare const carrySteps: (speed: number) => number;
+/** When each carried step lands (ms after the lift), slowing as it goes. */
+export declare const carryAt: (i: number) => number;
+/** Keeps a pan's recent moves (for `speedOf`), forgetting the old ones. */
+export declare function moves(): {
+    add(d: number, t?: number): void;
+    speed: () => number;
+    reset(): void;
+};
+/** How far (px) a text readout is giving right now, for the GPU to draw it there too. */
+export declare const giveOf: (el: Element) => number;
+/**
+ * A text readout's give (a number that can't go further). While in hand it's held where the
+ * pan puts it; let go, it springs home on one loop that both renderers read: the DOM as a
+ * `translate`, the GPU through `giveOf`.
+ */
+export declare function textGive(el: HTMLElement | SVGElement, wake: () => void): {
+    /** The give as last held (0 once let go). */
+    readonly give: number;
+    /** Holds the give at `px` (signed), ticking as it starts. */
+    hold(px: number): void;
+    /** Lets go: the give springs home. */
+    release(): void;
+};
+export type TextGive = ReturnType<typeof textGive>;

package/dist/types/panel/gpu/atlas.d.ts

@@ -0,0 +1,40 @@
+export declare const ATLAS_SIZE = 2048;
+export interface AtlasEntry {
+    readonly uv: readonly [number, number, number, number];
+    readonly w: number;
+    readonly h: number;
+    readonly pad: number;
+    readonly textW: number;
+}
+export declare class LabelAtlas {
+    private readonly doc;
+    readonly canvas: HTMLCanvasElement;
+    private readonly ctx;
+    private readonly map;
+    private lx;
+    private ly;
+    private rowH;
+    private dirty;
+    private dirtyY0;
+    private dirtyY1;
+    private currentScale;
+    constructor(doc: Document);
+    private attach;
+    detach(): void;
+    clear(): void;
+    /** Glyphs are rasterized at the canvas's own device-pixel ratio so they blit 1:1. */
+    ensureScale(scale: number): number;
+    /**
+     * Starts a frame: a nearly full atlas is cleared now rather than midway through a frame, which
+     * would strand glyphs already placed. Gliding font sizes and weights fill it fastest.
+     */
+    beginFrame(): void;
+    get(text: string, rawPx: number, rawWeight: number, family: string, scaleFactor?: number, letterSpacingEm?: number): AtlasEntry;
+    private readonly widths;
+    /** Advance width (CSS px) of `text`, measured with the browser's shaping, without rasterizing. */
+    measure(text: string, rawPx: number, rawWeight: number, family: string): number;
+    /** Rasterizes a 256×256 SVG path (Phosphor) at `px` CSS pixels into the atlas. */
+    icon(path: string, px: number, scaleFactor?: number): AtlasEntry;
+    get isDirty(): boolean;
+    flush(device: any, texture: any): void;
+}

package/dist/types/panel/gpu/color.d.ts

@@ -0,0 +1,128 @@
+export type Rgba = readonly [number, number, number, number];
+export declare function parseCssColor(raw: string, fallback?: Rgba): Rgba;
+export declare function withAlpha(c: Rgba, alphaFactor: number): Rgba;
+export declare function mixColor(a: Rgba, b: Rgba, t: number): Rgba;
+/** CSS `color-mix(in srgb, a p, b)`, interpolated with premultiplied alpha like the browser. */
+export declare function cssMix(a: Rgba, b: Rgba, p: number): Rgba;
+export interface PanelThemeTokens {
+    readonly bg: Rgba;
+    readonly surface: Rgba;
+    readonly surfaceHi: Rgba;
+    readonly line: Rgba;
+    readonly lineHi: Rgba;
+    readonly text: Rgba;
+    readonly label: Rgba;
+    readonly dim: Rgba;
+    readonly accent: Rgba;
+    readonly modified: Rgba;
+    readonly segBg: Rgba;
+    readonly segActive: Rgba;
+    readonly toggleTrack: Rgba;
+    readonly toggleThumb: Rgba;
+    readonly rim: Rgba;
+    /** The panel's hairline edge (--k-edge), drawn --k-rim-width wide like the rim. */
+    readonly edge: Rgba;
+    /** Width (CSS px) of the edge, the rim and the selected pill's outline (--k-rim-width). */
+    readonly rimWidth: number;
+    readonly rowHover: Rgba;
+    /** Space between rows (px); above 0 each row is its own bar rather than part of one card. */
+    readonly rowGap: number;
+    /** Hover wash in and out (ms). */
+    readonly hoverIn: number;
+    readonly hoverOut: number;
+    /** A slider handle's opacity at rest (0 shows it only on hover, focus and drag). */
+    readonly handleRest: number;
+    /** Group headings in small caps (`--k-group-transform: none` keeps their case). */
+    readonly groupUpper: boolean;
+    /** The slider handle's colour and how far inside the fill's edge it sits (px). */
+    readonly handle: Rgba;
+    readonly handleInset: number;
+    /** Group headings: size (px), colour, letter spacing (em) and the hairline above a group. */
+    readonly groupSize: number;
+    readonly groupColor: Rgba;
+    readonly groupTracking: number;
+    readonly groupDivider: Rgba;
+    /** Readout units: the space before them (px) and their colour. */
+    readonly unitGap: number;
+    /** null: the readout's own colour (`currentColor`). */
+    readonly unitColor: Rgba | null;
+    /** 1: a modified readout takes the modified colour behind a small dot. */
+    readonly readoutMark: number;
+    /** The readout's face. */
+    readonly valueFamily: string;
+    /** Spring curve: horizontal inset (px), one dashed guide at rest (vs. two solid), the running dot. */
+    readonly curveInset: number;
+    readonly curveDashed: boolean;
+    readonly curveDot: number;
+    readonly pillBg: Rgba;
+    readonly pillBorder: Rgba;
+    readonly fillRest: Rgba;
+    readonly fillActive: Rgba;
+    /** The fill under a hovered slider. */
+    readonly fillHover: Rgba;
+    /** 0 drops an inline panel's card: background, border and rim. */
+    readonly chrome: number;
+    /** A page's background (--k-page). */
+    readonly page: Rgba;
+    readonly pad: number;
+    readonly inset: number;
+    readonly row: number;
+    readonly gap: number;
+    readonly trayPad: number;
+    readonly radius: number;
+    readonly panelRadius: number;
+    readonly radiusMd: number;
+    readonly radiusSm: number;
+    readonly fontSize: number;
+    readonly textTitle: number;
+    readonly textBody: number;
+    readonly textControl: number;
+    readonly textMeta: number;
+    readonly textCap: number;
+    /** Readouts' size (--k-value-size, else a half pixel under the body size). */
+    readonly valueSize: number;
+    /** The button tokens (--k-button-*), where set; each element keeps its own look otherwise. */
+    readonly buttonBg: Rgba | null;
+    readonly buttonLine: Rgba | null;
+    readonly buttonHoverBg: Rgba | null;
+    readonly buttonHoverLine: Rgba | null;
+    readonly buttonRadius: number | null;
+    readonly buttonFontSize: number | null;
+    /** Buttons' label colour at rest (--k-button-color). */
+    readonly buttonColor: Rgba | null;
+    /** A fill or outline is set: action rows and preset chips are buttons (`[data-buttons]`). */
+    readonly boxed: boolean;
+    readonly iconSize: number;
+    readonly iconSm: number;
+    readonly labelWeight: number;
+    readonly disabledOpacity: number;
+    readonly hintTypedOpacity: number;
+    readonly blurStrength: number;
+    /** Smear on moving fill edges and selection pills, 0 (off) to 1 (--k-motion-blur). */
+    readonly motionBlur: number;
+    /** Smear on a range band's moving ends, 0 (off) to 1 (--k-range-blur). */
+    readonly rangeBlur: number;
+    readonly glowStrength: number;
+    /** 0 is an opaque panel; up to 1 thins it over a blurred backdrop (--k-glass). */
+    readonly glass: number;
+    /** Backdrop brightness under full glass (dims what shows through dark panels). */
+    readonly glassTone: number;
+    /** The spring values settle on (--k-spring: duration bounce), as ω and ζ. */
+    readonly fillOmega: number;
+    readonly fillZeta: number;
+    readonly fontFamily: string;
+    readonly monoFamily: string;
+    readonly isLight: boolean;
+    /** Body and readout weight (--k-font-weight) and titles' and headings' (--k-title-weight). */
+    readonly fontWeight: number;
+    readonly titleWeight: number;
+    /** Round things' radius (--k-round): fully round unless --k-radius is 0, or a px value. */
+    readonly round: number;
+    /** `flat`: groups draw no card surfaces and rows square off (--k-frame). */
+    readonly flat: boolean;
+    /** A switch's thumb when off, and colour strips' rings (--k-thumb). */
+    readonly thumb: Rgba;
+    /** How strongly small drop shadows show under thumbs and pills (--k-lift). */
+    readonly lift: number;
+}
+export declare function readPanelTokens(panel: HTMLElement, version?: number): PanelThemeTokens;

package/dist/types/panel/gpu/die.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const DIE_WGSL: string;