@mkbabb/glass-ui 4.0.1 → 4.2.0

package/dist/components/custom/confirm-dialog/ConfirmDialog.vue.d.ts

@@ -9,11 +9,11 @@ type __VLS_ModelProps = {
     "open"?: boolean;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_13: {}, __VLS_36: {};
+declare var __VLS_35: {}, __VLS_64: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_13) => any;
+    default?: (props: typeof __VLS_35) => any;
 } & {
-    action?: (props: typeof __VLS_36) => any;
+    action?: (props: typeof __VLS_64) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;

package/dist/components/custom/constellation/Constellation.vue.d.ts

@@ -4,8 +4,13 @@ declare const __VLS_export: import("vue").DefineComponent<ConstellationProps, im
     speed: number;
     count: number;
     opacityCeiling: number;
+    parallax: number;
     pointerReactive: boolean;
     warpOnClick: boolean;
+    wander: boolean | {
+        minIdle?: number;
+        jitter?: number;
+    };
     gravityWell: boolean | {
         holdMs?: number;
         gain?: number;
@@ -14,10 +19,6 @@ declare const __VLS_export: import("vue").DefineComponent<ConstellationProps, im
         maxSpeed?: number;
         soften?: number;
     };
-    wander: boolean | {
-        minIdle?: number;
-        jitter?: number;
-    };
     pinned: boolean | number;
     accentEdges: boolean;
     pinnedDrift: boolean | {

package/dist/components/custom/constellation/composables/constellationGLSetup.d.ts

@@ -0,0 +1,10 @@
+import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
+import type { ConstellationRenderState } from "./constellationWGPUSetup";
+export interface ConstellationGLSetupDeps {
+    canvas: HTMLCanvasElement;
+    resolveFrame: (timeSec: number) => ConstellationRenderState | null;
+    onResize?: (w: number, h: number) => void;
+    shouldContinue: () => boolean;
+}
+/** Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes. */
+export declare function createConstellationGLSetup(deps: ConstellationGLSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/custom/constellation/composables/constellationWGPUSetup.d.ts

@@ -0,0 +1,19 @@
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import { type ConstellationUniformValues, type PackedNode, type PackedEdge } from "./uniformBridgeWGPU";
+/** The per-frame render state the renderer resolves (the stepped field → packed rows). */
+export interface ConstellationRenderState {
+    nodes: PackedNode[];
+    edges: PackedEdge[];
+    uniforms: ConstellationUniformValues;
+}
+export interface ConstellationWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    /** Advance the field + the shared pointer field one renderer frame, return the packed render state. */
+    resolveFrame: (timeSec: number) => ConstellationRenderState | null;
+    /** Size the canvas backing store (returns the resolved backing-store [w,h] in device px). */
+    onResize?: (w: number, h: number) => void;
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+}
+/** Build the constellation `setupWGPU(device, context, format)` callback. */
+export declare function createConstellationWGPUSetup(deps: ConstellationWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/constellation/composables/uniformBridgeWGPU.d.ts

@@ -0,0 +1,66 @@
+/** Floats per node row (one vec4). */
+export declare const NODE_FLOATS = 4;
+/** Bytes per node row. */
+export declare const NODE_BYTES: number;
+/** The pre-sized node storage buffer byte length. */
+export declare const NODES_BUFFER_BYTES: number;
+/** Floats per edge row (2 vec4s). */
+export declare const EDGE_FLOATS = 8;
+/** Bytes per edge row. */
+export declare const EDGE_BYTES: number;
+/** The pre-sized edge storage buffer byte length. */
+export declare const EDGES_BUFFER_BYTES: number;
+export declare const CONSTELLATION_UNIFORM_BYTES = 112;
+export interface ConstellationUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+}
+export declare function createConstellationScratch(): ConstellationUniformScratch;
+/** The per-frame uniform values the render reads (resolved JS-side). */
+export interface ConstellationUniformValues {
+    resolutionX: number;
+    resolutionY: number;
+    dpr: number;
+    kVis: number;
+    time: number;
+    lineWidth: number;
+    opacityCeiling: number;
+    /** The field-yields-to-type `--constellation-alpha` global dimmer. */
+    alpha: number;
+    edgeAlpha: number;
+    edgeFocusAlpha: number;
+    edgeAccentAlpha: number;
+    edgeFloor: number;
+    /** Premultiplied-ready RGBA (`[0,1]`) — `node`/`nodeDim`/`line`/`accent`. */
+    node: [number, number, number, number];
+    nodeDim: [number, number, number, number];
+    line: [number, number, number, number];
+    accent: [number, number, number, number];
+}
+/** Pack the constellation uniforms in place. */
+export declare function packConstellationUniforms(scratch: ConstellationUniformScratch, v: ConstellationUniformValues): ConstellationUniformScratch;
+/** A pre-sized node scratch (`MAX_NODES` rows × NODE_FLOATS). */
+export declare function createNodeScratch(): Float32Array;
+/** A pre-sized edge scratch (`E_MAX` rows × EDGE_FLOATS). */
+export declare function createEdgeScratch(): Float32Array;
+/** A packed node row in screen-px: `(x, y, radius, dim)`. */
+export interface PackedNode {
+    x: number;
+    y: number;
+    r: number;
+    dim: number;
+}
+/** Pack `count` node rows into the scratch (clamped to MAX_NODES). Returns the count packed. */
+export declare function packNodes(scratch: Float32Array, nodes: readonly PackedNode[]): number;
+/** A packed edge row: `(ax, ay, bx, by, alpha, accent, focus)`. */
+export interface PackedEdge {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    alpha: number;
+    accent: number;
+    focus: number;
+}
+/** Pack `count` edge rows into the scratch (clamped to E_MAX). Returns the count packed. */
+export declare function packEdges(scratch: Float32Array, edges: readonly PackedEdge[]): number;

package/dist/components/custom/constellation/composables/useConstellation.d.ts

@@ -1,9 +1,12 @@
 import { type Ref } from "vue";
+import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
 import { type ConstellationField, type ConstellationProps } from "../constellationField";
 /** The imperative seam the SFC re-exposes via `defineExpose`. */
 export interface ConstellationExpose {
     field: ConstellationField;
     isFrozen: Ref<boolean>;
+    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 instanced twin). */
+    backend: () => GpuBackend;
     warpTo(a: {
         x: number;
         y: number;
@@ -13,14 +16,4 @@ export interface ConstellationExpose {
     warpSettled(): boolean;
     pinNode(idx: number): void;
 }
-/**
- * Drive a `<Constellation>` instance. `props` is the REACTIVE (defaulted) prop
- * surface — the per-frame live-read props (`pointerReactive`/`opacityCeiling`/
- * `accentEdges`/`drawOverlay`) are read off `props.x` INSIDE the render loop so a
- * bound `:opacity-ceiling` updates without a remount (the Vue 3.5 reactive-prop
- * read; the SFC `defineProps` destructure transform does not reach a composable
- * argument, so the live reads stay on `props`). `hostRef`/`canvasRef` are the SFC
- * template refs. Returns the imperative expose object the SFC spreads into
- * `defineExpose`.
- */
 export declare function useConstellation(props: ConstellationProps, hostRef: Ref<HTMLElement | null>, canvasRef: Ref<HTMLCanvasElement | null>): ConstellationExpose;

package/dist/components/custom/constellation/constants.d.ts

@@ -59,3 +59,36 @@ export declare const DEFAULT_PINNED_DRIFT_JITTER = 8000;
  *  ≥ ~0.72·BASE_WIDTH ≈ 922px (incl. the 1280 export frame — byte-identical
  *  there by construction); below it the marks stop crushing sub-pixel. */
 export declare const DEFAULT_K_FLOOR = 0.72;
+/**
+ * The maximum node count the points/edges buffers pre-size for (the slider cap — a count
+ * above this is clamped at upload). ≫ this BOOKS the compute neighbor-bin path.
+ */
+export declare const MAX_NODES = 256;
+/**
+ * The per-node max degree budget — the edge buffer is pre-sized at `MAX_NODES · MAX_DEGREE`
+ * so the CPU all-pairs scan never overflows it (a denser-than-degree neighborhood drops the
+ * weakest edges, never re-allocates). 12 is a generous incident-edge ceiling for a
+ * distance-threshold ε-proximity graph at the default link/count.
+ */
+export declare const MAX_DEGREE = 12;
+/** The pre-sized edge instance budget (`MAX_NODES · MAX_DEGREE`). */
+export declare const E_MAX: number;
+/**
+ * The pointer-parallax depth default (§6). Each node carries a seeded depth `z ∈ [0,1]`;
+ * the pointer offsets node screen positions by `parallax · z · (pointer − center)` — a
+ * cheap pointer-parallax giving the flat lattice apparent depth (the Awwwards "living
+ * network" register). Additive default-on at a SUB-PERCEPTUAL 0.08 (a hair of depth, not a
+ * behavior break). 0 = the flat lattice (no parallax).
+ */
+export declare const DEFAULT_PARALLAX = 0.08;
+/**
+ * The base node radius band (CSS px) the DPR-aware SDF circle sizes within (the §1 "Node
+ * size" config axis). `seedField` rolls each node's radius in `[NODE_R_MIN, NODE_R_MIN +
+ * NODE_R_SPREAD)` (the prior `1.6 + rng()*1.6` band, named); the WGSL/GLSL fragment SDF
+ * sizes `half = radius · uKVis · uDpr / uResolution` so the disc samples at full device
+ * resolution and is AA'd by the pixel-footprint derivative — crisp at ANY DPR.
+ */
+export declare const NODE_R_MIN = 1.6;
+export declare const NODE_R_SPREAD = 1.6;
+/** The hairline edge half-width (CSS px) the instanced segment-quad fragment AAs. */
+export declare const DEFAULT_LINE_WIDTH = 1;

package/dist/components/custom/constellation/constellationField.d.ts

@@ -39,4 +39,34 @@ export declare function refitField(field: ConstellationField, prevW: number, pre
  * `setWarpTarget` to a random node when it elapses AND the spring has settled
  * (a click-warp in flight pre-empts the cadence — `warpSettled` reports false).
  */
-export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number, now?: number, rng?: () => number): void;
+export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number, now?: number, rng?: () => number, pointerVel?: ConstellationPointer | null): void;
+import type { ConstellationEdge } from "./constellationTypes";
+/**
+ * Scan the proximity graph and return its edge SET (the `1 − d²/reach²` distance-falloff
+ * weight per pair within `reach = link·k`). `accentIndex ≥ 0` marks the edges incident on
+ * that node (the flagged-node tether). Pure + node-testable; the render loop calls it each
+ * frame and uploads the result to the instanced-lines storage buffer.
+ *
+ * `eMax` caps the result (the pre-sized buffer budget). When the scan would exceed it, the
+ * WEAKEST overflow edges are dropped (a denser-than-budget neighborhood keeps its strongest
+ * links — never re-allocates the GPU buffer mid-frame).
+ */
+export declare function buildEdges(field: ConstellationField, link: number, accentIndex?: number, eMax?: number): ConstellationEdge[];
+/**
+ * Append the POINTER-WEB tether edges to an existing edge set (the `drawPointerWeb` math
+ * relocated): the cursor is a "virtual node" whose incident edges (to every node within
+ * `reach`) carry `focus = 1` (the render strokes them at the focus alpha). No-op when the
+ * pointer is inactive (`x < 0`). The `eMax` budget is shared with the ambient set.
+ */
+export declare function appendPointerWeb(edges: ConstellationEdge[], field: ConstellationField, link: number, pointer: ConstellationPointer | null, eMax?: number): void;
+/**
+ * The parallax-offset SCREEN position for a node (§6). Offsets the node by
+ * `parallax · z · (pointer − center)` — a cheap pointer-parallax giving the flat lattice
+ * apparent depth (deeper nodes — higher `z` — shift more, the Awwwards "living network"
+ * register). When the pointer is inactive the offset is 0 (the flat lattice). Pure; the
+ * render loop maps each node's `(x,y)` through this before writing the GPU position buffer.
+ */
+export declare function parallaxNodePos(node: ConstellationNode, pointer: ConstellationPointer | null, w: number, h: number, parallax: number): {
+    x: number;
+    y: number;
+};

package/dist/components/custom/constellation/constellationInteraction.d.ts

@@ -19,20 +19,7 @@ export declare function readInteractionConfig(canvas: HTMLCanvasElement): {
         jitter: number;
     };
 };
-/**
- * Advance the gravity-well one `dt` (AY.W-CON2). A transient held-pointer force
- * composed inside `stepField` (NO new rAF): ease `well.strength` toward
- * `well.target` (1 held / 0 released) at `cfg.ramp`/s; while active, add an
- * inverse-square pull toward the held point onto each node within `cfg.reach`
- * (the `max(d, soften)` no-singularity floor + the `cfg.maxSpeed` no-slingshot
- * clamp); ALWAYS ease every node's |v| back toward `speed` (the field-cools
- * invariant — so a released well re-settles). No-ops (entirely skipped) when
- * `field.well` is undefined → the default render is byte-identical to HEAD.
- *
- * `dt` is clamped to {@link WARP_DT_CLAMP} (the same park-resume guard the warp
- * uses) so a tab-throttle gap cannot slingshot the field in one giant step.
- */
-export declare function stepWell(field: ConstellationField, k: number, speed: number, dt: number): void;
+export { stepWell } from "./constellationWell";
 /**
  * The nearest DRIFTING node to `(px, py)` in canvas-local px — a linear O(count)
  * min-d² scan (count 64 default — negligible; matches the O(count²) edge pass).
@@ -130,3 +117,25 @@ export declare function makePinnedDrift(override?: {
  * rests at the leg's end, the next leg arming after `minIdle + rng()*jitter`.
  */
 export declare function stepPinnedDrift(field: ConstellationField, now: number, rng: () => number): void;
+/** The flick-burst threshold (the shared usePointerVelocityField `burst` 0..1) above which
+ *  a fast flick fires the focal warp + a transient ripple (a slow drag never fires). */
+export declare const BURST_FIRE_THRESHOLD = 0.45;
+/**
+ * Fire a focal BURST off a flick (the §E "reads velocity AND acceleration" mandate). A high
+ * `burst` (from the shared `usePointerVelocityField`, the eased flick impulse) warps the
+ * focal node toward the cursor (the warp spring snaps it) AND drops an expanding ripple at
+ * the focal — the lattice "snaps the focal toward the cursor and drops an expanding ring"
+ * (the WGSL ripple instance / the accent-ring overlay). A slow drag (`burst` below the
+ * threshold) never fires (a steady hover is the gentle gather, not a snap). Returns true
+ * when a burst fired. Composes the EXISTING `warpTo` + the ripple list — no new mechanic,
+ * no second rAF (the warp rides the substrate's ONE clock); PRM is enforced by the CALLER
+ * (the shared field's `tick(0)` zeroes `burst` under reduce, so this never fires).
+ */
+export declare function fireBurst(field: ConstellationField, pointer: {
+    x: number;
+    y: number;
+}, burst: number, ripples: {
+    x: number;
+    y: number;
+    start: number;
+}[]): boolean;

package/dist/components/custom/constellation/constellationRender.d.ts

@@ -0,0 +1,25 @@
+import type { ConstellationField, ConstellationPalette } from "./constellationField";
+import { DEFAULT_PALETTE } from "./constants";
+/** R5-8 — the visual-SIZE draw scale: `max(k, kFloor)`. The instanced disc/segment
+ *  geometry sizes on this; positions/reach stay on TRUE `field.k`. Exported so a
+ *  consumer skin floors its own marks on the same axis. */
+export declare function kVisOf(field: ConstellationField): number;
+export { DEFAULT_PALETTE };
+/**
+ * Resolve the FULL neutral palette + legibility weights off a canvas's resolved custom
+ * properties (the `--constellation-*` set). The colors AND the alpha multipliers route
+ * through the same `getComputedStyle` probe, so a dark-mode flip re-resolves BOTH the
+ * `:root`/`.dark` color arms AND the per-mode alpha defaults in one read. SSR-safe
+ * (returns the warm-cream defaults with no `window`).
+ */
+export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
+/**
+ * Parse a CSS color string (the `--constellation-*` hsl/hex literals the palette carries)
+ * into a linear-ish premultiplied-ready RGBA in `[0,1]` for the GPU uniform write. A small
+ * sRGB parser: it reads `#rgb`/`#rrggbb`/`#rrggbbaa`, `rgb()/rgba()`, and `hsl()/hsla()` —
+ * the forms the `--constellation-*` token authoring uses (PLAIN-hsl per arm). The shader
+ * outputs premultiplied alpha over the transparent clear, so the render loop multiplies the
+ * `a` into the uniform color at upload (kept here so there is ONE color parse seam). Falls
+ * back to opaque warm-ink on an unparseable value (never a NaN garbage write).
+ */
+export declare function parseColorRGBA(input: string): [number, number, number, number];

package/dist/components/custom/constellation/constellationTypes.d.ts

@@ -5,6 +5,35 @@ export interface ConstellationNode {
     vy: number;
     r: number;
     dim: boolean;
+    /**
+     * BC.W-VIZ-CONSTELLATION — the seeded parallax DEPTH (`z ∈ [0,1]`, §6). The pointer
+     * offsets the node's SCREEN position by `parallax · z · (pointer − center)` so the flat
+     * lattice reads as having depth (the Awwwards "living network" register). Seeded in
+     * `seedField`; perturbs the GPU node-position write only (never a layout property). A
+     * field literal that omits it is treated as `z = 0.5` (the mid-plane, no parallax bias).
+     */
+    z?: number;
+}
+/**
+ * BC.W-VIZ-CONSTELLATION — ONE edge of the proximity graph, the row the CPU all-pairs scan
+ * (`buildEdges`) writes each frame into the instanced-lines storage buffer. `a`/`b` are the
+ * two endpoint positions in canvas-local CSS px; `alpha` is the distance-falloff weight
+ * (`1 − d²/reach²`, the `drawEdges` math) the segment-quad fragment multiplies; `accent`
+ * (0/1) flags the accented-node tether (the flagged-node edge tint); `focus` (0/1) flags
+ * the pointer-web tether (the cursor's incident edges). The WGSL/GLSL render transcribes
+ * the SHAPE, never re-derives the scan (the ONE math source stays JS).
+ */
+export interface ConstellationEdge {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    /** The distance-falloff weight `1 − d²/reach²` (the drawEdges math). */
+    alpha: number;
+    /** 1 when the edge is incident on the accented node (the tether tint), else 0. */
+    accent: number;
+    /** 1 when the edge is a pointer-web tether (the cursor's incident edge), else 0. */
+    focus: number;
 }
 export interface ConstellationRipple {
     x: number;
@@ -274,6 +303,15 @@ export interface ConstellationProps {
     link?: number;
     /** Drift speed. Default 0.16. */
     speed?: number;
+    /**
+     * BC.W-VIZ-CONSTELLATION (§6) — the pointer-PARALLAX depth. Each node carries a seeded
+     * depth `z ∈ [0,1]`; the pointer offsets node screen positions by `parallax · z ·
+     * (pointer − center)` so the flat lattice reads as having depth (the Awwwards "living
+     * network" register). Additive default-on at a SUB-PERCEPTUAL 0.08 (a hair of depth, not
+     * a behavior break); 0 = the flat lattice. GPU-only (perturbs the node-position write,
+     * never a layout property). Frozen under reduced-motion / `freeze`.
+     */
+    parallax?: number;
     /**
      * AY.W-COHERE E3 — the per-instance outer-envelope RECESSION knob (the aurora
      * `opacityCeiling` / fourier `intensity` sibling — ONE recession vocabulary

package/dist/components/custom/constellation/constellationWell.d.ts

@@ -0,0 +1,15 @@
+import type { ConstellationField } from "./constellationField";
+/**
+ * Advance the gravity-well one `dt` (AY.W-CON2). A transient held-pointer force
+ * composed inside `stepField` (NO new rAF): ease `well.strength` toward
+ * `well.target` (1 held / 0 released) at `cfg.ramp`/s; while active, add an
+ * inverse-square pull toward the held point onto each node within `cfg.reach`
+ * (the `max(d, soften)` no-singularity floor + the `cfg.maxSpeed` no-slingshot
+ * clamp); ALWAYS ease every node's |v| back toward `speed` (the field-cools
+ * invariant — so a released well re-settles). No-ops (entirely skipped) when
+ * `field.well` is undefined → the default render is byte-identical to HEAD.
+ *
+ * `dt` is clamped to {@link WELL_DT_CLAMP} (the same park-resume guard the warp
+ * uses) so a tab-throttle gap cannot slingshot the field in one giant step.
+ */
+export declare function stepWell(field: ConstellationField, k: number, speed: number, dt: number): void;

package/dist/components/custom/constellation/index.d.ts

@@ -1,6 +1,6 @@
 export { default as Constellation } from "./Constellation.vue";
-export { seedField, stepField, refitField, BASE_WIDTH, } from "./constellationField";
-export { DEFAULT_K_FLOOR } from "./constants";
-export { stepWell, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, stepPinnedDrift, makePinnedDrift, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER, WARP_RESPONSE, WARP_ZETA, } from "./constellationInteraction";
-export { kVisOf, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, DEFAULT_PALETTE, } from "./constellationDraw";
-export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";
+export { seedField, stepField, refitField, buildEdges, appendPointerWeb, parallaxNodePos, BASE_WIDTH, } from "./constellationField";
+export { DEFAULT_K_FLOOR, DEFAULT_PARALLAX, MAX_NODES, MAX_DEGREE, E_MAX, } from "./constants";
+export { stepWell, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, stepPinnedDrift, makePinnedDrift, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER, WARP_RESPONSE, WARP_ZETA, fireBurst, BURST_FIRE_THRESHOLD, } from "./constellationInteraction";
+export { kVisOf, readPalette, parseColorRGBA, DEFAULT_PALETTE, } from "./constellationRender";
+export type { ConstellationNode, ConstellationEdge, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";

package/dist/components/custom/constellation/shaders/constellation-lines.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const CONSTELLATION_LINES_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n// per-instance edge rows \u2014 vertexAttribDivisor(1).\nlayout(location = 0) in vec4 aAB;  // (a.x, a.y, b.x, b.y)\nlayout(location = 1) in vec4 aW;   // (alpha, accent, focus, _pad)\n\nuniform vec2 uResolution;\nuniform float uDpr;\nuniform float uKVis;\nuniform float uLineWidth;\n\nout float vLineCoord;\nout float vAlpha;\nout float vAccent;\nout float vFocus;\n\nvoid main() {\n  vec2 quad[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0,  1.0), vec2(1.0, -1.0), vec2(1.0,  1.0)\n  );\n  vec2 alongQuad = quad[gl_VertexID];\n\n  vec2 a = aAB.xy;\n  vec2 b = aAB.zw;\n  vec2 dir = normalize(b - a + vec2(1e-6, 0.0));\n  vec2 ortho = vec2(-dir.y, dir.x);\n  // accent tether reads a touch heavier (1.1\u00D7).\n  float halfWPx = uLineWidth * uKVis * uDpr * 0.5 * mix(1.0, 1.1, aW.y);\n  vec2 p = mix(a, b, alongQuad.x * 0.5 + 0.5) + ortho * alongQuad.y * halfWPx;\n\n  vec2 ndc = vec2(\n    p.x / max(uResolution.x, 1.0) * 2.0 - 1.0,\n    1.0 - p.y / max(uResolution.y, 1.0) * 2.0\n  );\n\n  gl_Position = vec4(ndc, 0.0, 1.0);\n  vLineCoord = alongQuad.y;\n  vAlpha = aW.x;\n  vAccent = aW.y;\n  vFocus = aW.z;\n}\n";
+export declare const CONSTELLATION_LINES_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\nuniform vec4 uLine;     // premultiplied-ready rgba\nuniform vec4 uAccent;\nuniform float uAlphaGlobal;       // --constellation-alpha\nuniform float uOpacityCeiling;\nuniform float uEdgeAlpha;\nuniform float uEdgeFocusAlpha;\nuniform float uEdgeAccentAlpha;\nuniform float uEdgeFloor;\n\nin float vLineCoord;\nin float vAlpha;\nin float vAccent;\nin float vFocus;\nout vec4 fragColor;\n\nvoid main() {\n  float aaBand = 0.6;\n  float cross = 1.0 - smoothstep(1.0 - aaBand, 1.0, abs(vLineCoord));\n  if (cross <= 0.0) { discard; }\n\n  float dim = uAlphaGlobal * uOpacityCeiling;\n  vec4 col = uLine;\n  float weight = (uEdgeAlpha * vAlpha + uEdgeFloor) * dim;\n  if (vAccent > 0.5) {\n    col = uAccent;\n    weight = uEdgeAccentAlpha * vAlpha * dim;\n  } else if (vFocus > 0.5) {\n    col = uLine;\n    weight = uEdgeFocusAlpha * uAlphaGlobal * uOpacityCeiling * vAlpha;\n  }\n\n  float a = col.a * weight * cross;\n  if (a <= 0.0) { discard; }\n  fragColor = vec4(col.rgb * a, a);\n}\n";

package/dist/components/custom/constellation/shaders/constellation-lines.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const CONSTELLATION_LINES_WGSL = "\nstruct Edge {\n  // vec4 0: (a.x, a.y, b.x, b.y)\n  ab: vec4<f32>,\n  // vec4 1: (alpha, accent, focus, _pad)\n  w: vec4<f32>,\n};\n\nstruct ConstellationUniforms {\n  // u0: (resolution.x, resolution.y, dpr, kVis)\n  u0: vec4<f32>,\n  // u1: (time, lineWidth, opacityCeiling, alpha)\n  u1: vec4<f32>,\n  // uEdge: (edgeAlpha, edgeFocusAlpha, edgeAccentAlpha, edgeFloor)\n  uEdge: vec4<f32>,\n  uNode: vec4<f32>,\n  uNodeDim: vec4<f32>,\n  uLine: vec4<f32>,\n  uAccent: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConstellationUniforms;\n@group(0) @binding(1) var<storage, read> edges: array<Edge>;\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) lineCoord: f32,  // [-1,1] cross-line \u2192 fragment AA\n  @location(1) alpha: f32,      // distance-falloff weight\n  @location(2) accent: f32,     // accent flag (the flagged-node tether tint)\n  @location(3) focus: f32,      // focus flag (the pointer-web tether)\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vIdx: u32,\n  @builtin(instance_index) iIdx: u32,\n) -> VSOut {\n  var QUAD = array<vec2<f32>, 6>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),\n    vec2<f32>(-1.0,  1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0,  1.0),\n  );\n  let alongQuad = QUAD[vIdx];\n\n  let e = edges[iIdx];\n  let a = e.ab.xy;\n  let b = e.ab.zw;\n  let res = u.u0.xy;\n  let dpr = u.u0.z;\n  let kVis = u.u0.w;\n  let lineW = u.u1.y;\n\n  // Screen-space segment direction + orthogonal (the half-width offset axis).\n  let dir = normalize(b - a + vec2<f32>(1e-6, 0.0));\n  let ortho = vec2<f32>(-dir.y, dir.x);\n  // Lerp along the segment (alongQuad.x \u2208 [-1,1] \u2192 [0,1]); offset by ortho \u00D7 half-width.\n  // The accent tether reads a touch heavier (1.1\u00D7 the neutral width).\n  let halfWPx = lineW * kVis * dpr * 0.5 * mix(1.0, 1.1, e.w.y);\n  let p = mix(a, b, alongQuad.x * 0.5 + 0.5) + ortho * (alongQuad.y) * halfWPx;\n\n  // px (y-down) \u2192 clip (y-up).\n  let ndc = vec2<f32>(\n    p.x / max(res.x, 1.0) * 2.0 - 1.0,\n    1.0 - p.y / max(res.y, 1.0) * 2.0,\n  );\n\n  var out: VSOut;\n  out.pos = vec4<f32>(ndc, 0.0, 1.0);\n  out.lineCoord = alongQuad.y;\n  out.alpha = e.w.x;\n  out.accent = e.w.y;\n  out.focus = e.w.z;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // Cross-line AA \u2014 a smoothstep on |lineCoord| so the hairline edge is crisp.\n  let aaBand = 0.6;\n  let cross = 1.0 - smoothstep(1.0 - aaBand, 1.0, abs(in.lineCoord));\n  if (cross <= 0.0) { discard; }\n\n  let dim = u.u1.w * u.u1.z; // alpha \u00B7 opacityCeiling\n  // Resolve the edge class: accent tether \u00B7 focus pointer-web \u00B7 neutral ambient.\n  var col = u.uLine;\n  var weight = (u.uEdge.x * in.alpha + u.uEdge.w) * dim; // edgeAlpha\u00B7falloff + edgeFloor\n  if (in.accent > 0.5) {\n    col = u.uAccent;\n    weight = u.uEdge.z * in.alpha * dim; // edgeAccentAlpha\n  } else if (in.focus > 0.5) {\n    col = u.uLine;\n    weight = u.uEdge.y * u.u1.w * u.u1.z * in.alpha; // edgeFocusAlpha \u00B7 alpha \u00B7 ceiling\n  }\n\n  let a = col.a * weight * cross;\n  if (a <= 0.0) { discard; }\n  return vec4<f32>(col.rgb * a, a);\n}\n";

package/dist/components/custom/constellation/shaders/constellation-points.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const CONSTELLATION_POINTS_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n// per-instance node row (x, y, radius, dim) \u2014 vertexAttribDivisor(1).\nlayout(location = 0) in vec4 aNode;\n\nuniform vec2 uResolution;\nuniform float uDpr;\nuniform float uKVis;\n\nout vec2 vUv;   // [-1,1] billboard-local \u2192 fragment SDF coord\nout float vDim;\n\nvoid main() {\n  // Two-triangle quad corners (the SAME order as the WGSL QUAD).\n  vec2 quad[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0,  1.0), vec2(1.0, -1.0), vec2(1.0,  1.0)\n  );\n  vec2 corner = quad[gl_VertexID];\n\n  vec2 centerPx = aNode.xy;\n  // px (y-down) \u2192 clip (y-up).\n  vec2 centerNdc = vec2(\n    centerPx.x / max(uResolution.x, 1.0) * 2.0 - 1.0,\n    1.0 - centerPx.y / max(uResolution.y, 1.0) * 2.0\n  );\n  // half-extent: radius\u00B7kVis CSS px \u2192 backing-store px (\u00B7dpr) \u2192 NDC half (\u00B72/res).\n  // (half is a GLSL reserved word \u2014 name it halfExt.)\n  float radPx = aNode.z * uKVis * uDpr;\n  vec2 halfExt = vec2(\n    radPx / max(uResolution.x, 1.0) * 2.0,\n    radPx / max(uResolution.y, 1.0) * 2.0\n  );\n\n  gl_Position = vec4(centerNdc + corner * halfExt, 0.0, 1.0);\n  vUv = corner;\n  vDim = aNode.w;\n}\n";
+export declare const CONSTELLATION_POINTS_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\nuniform vec4 uNode;      // premultiplied-ready rgba\nuniform vec4 uNodeDim;\nuniform float uOpacityCeiling;\n\nin vec2 vUv;\nin float vDim;\nout vec4 fragColor;\n\nvoid main() {\n  // SDF: distance to the unit-circle edge (0 at the rim, neg inside).\n  float d = length(vUv) - 1.0;\n  // fwidth(d) \u2014 the pixel footprint, the resolution-independent AA width.\n  float aa = max(fwidth(d), 1e-4);\n  float coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage <= 0.0) { discard; }\n  vec4 col = mix(uNode, uNodeDim, vDim);\n  float a = col.a * coverage * uOpacityCeiling;\n  fragColor = vec4(col.rgb * a, a); // premultiplied\n}\n";

package/dist/components/custom/constellation/shaders/constellation-points.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const CONSTELLATION_POINTS_WGSL = "\n// \u2500\u2500 Node storage row + uniforms (the typed-struct source-of-truth \u2014 uniformBridgeWGPU.ts) \u2500\u2500\nstruct Node {\n  // (pos.x, pos.y, radius, dim)\n  data: vec4<f32>,\n};\n\nstruct ConstellationUniforms {\n  // u0: (resolution.x, resolution.y, dpr, kVis)\n  u0: vec4<f32>,\n  // u1: (time, lineWidth, opacityCeiling, alpha)\n  u1: vec4<f32>,\n  // uEdge: (edgeAlpha, edgeFocusAlpha, edgeAccentAlpha, edgeFloor)\n  uEdge: vec4<f32>,\n  // colours (premultiplied-ready rgba)\n  uNode: vec4<f32>,\n  uNodeDim: vec4<f32>,\n  uLine: vec4<f32>,\n  uAccent: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConstellationUniforms;\n@group(0) @binding(1) var<storage, read> nodes: array<Node>;\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,   // [-1,1] billboard-local \u2192 fragment SDF coord\n  @location(1) dim: f32,        // 0 = full node, 1 = dim node\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vIdx: u32,\n  @builtin(instance_index) iIdx: u32,\n) -> VSOut {\n  // Two-triangle quad corners in billboard-local space.\n  var QUAD = array<vec2<f32>, 6>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),\n    vec2<f32>(-1.0,  1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0,  1.0),\n  );\n  let corner = QUAD[vIdx];\n\n  let node = nodes[iIdx].data;\n  let res = u.u0.xy;\n  let dpr = u.u0.z;\n  let kVis = u.u0.w;\n\n  // center: node px \u2192 clip space (y-flip \u2014 px is y-down, clip is y-up).\n  let centerPx = node.xy;\n  let centerNdc = vec2<f32>(\n    centerPx.x / max(res.x, 1.0) * 2.0 - 1.0,\n    1.0 - centerPx.y / max(res.y, 1.0) * 2.0,\n  );\n  // half-extent: radius\u00B7kVis in CSS px \u2192 backing-store px (\u00B7dpr) \u2192 NDC half (\u00B72/res).\n  // (the DPR-aware crispness leg \u2014 the disc samples at device resolution.)\n  // (half is a WGSL reserved keyword \u2014 name it halfExt.)\n  let radPx = node.z * kVis * dpr;\n  let halfExt = vec2<f32>(radPx / max(res.x, 1.0) * 2.0, radPx / max(res.y, 1.0) * 2.0);\n\n  var out: VSOut;\n  out.pos = vec4<f32>(centerNdc + corner * halfExt, 0.0, 1.0);\n  out.uv = corner;\n  out.dim = node.w;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // SDF: distance to the unit-circle edge in billboard-local space (0 at the rim, neg inside).\n  let d = length(in.uv) - 1.0;\n  // fwidth(d) = |dpdx(d)| + |dpdy(d)| \u2014 the pixel footprint of the SDF, the resolution-\n  // independent AA width (~1px band at ANY DPR/zoom/size).\n  let aa = max(fwidth(d), 1e-4);\n  let coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage <= 0.0) { discard; }\n  let col = mix(u.uNode, u.uNodeDim, in.dim);\n  let a = col.a * coverage * u.u1.z;  // \u00B7opacityCeiling\n  // premultiplied-alpha output.\n  return vec4<f32>(col.rgb * a, a);\n}\n";

package/dist/components/custom/deck/DeckPager.vue.d.ts

@@ -0,0 +1,29 @@
+type __VLS_Props = {
+    /** Total slide count. */
+    total: number;
+    /** Window to `fit` dots centered on the active dot. Off → show every dot. */
+    windowFit?: number;
+    /** Encapsulate the rail in the glass pager pill chassis. Default false —
+        a deck owns its own ambient glass host, so the dots sit FLUSH on it. */
+    ring?: boolean;
+    /** Accessible name for the rail group. */
+    ariaLabel?: string;
+};
+type __VLS_ModelProps = {
+    /** v-model:index — the active 0-based slide index. */
+    "index"?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:index": (value: number) => any;
+} & {
+    select: (index: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((index: number) => any) | undefined;
+    "onUpdate:index"?: ((value: number) => any) | undefined;
+}>, {
+    ariaLabel: string;
+    ring: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/deck/composables/useDeck.d.ts

@@ -0,0 +1,27 @@
+import { type ComputedRef, type Ref } from "vue";
+export interface DeckCore {
+    /** The 0-based active slide index (clamped to [0, total-1]). */
+    index: Ref<number>;
+    /** The total slide count. */
+    total: number;
+    /** 1-based completion as a percentage (slide 1 of N → 100/N), for a bar. */
+    progress: ComputedRef<number>;
+    /** The accessible "Slide N of M" announcement off the live index (§3 — the
+        portable aria-live seam; surface it in an `sr-only` polite region). */
+    liveMessage: ComputedRef<string>;
+    go: (i: number) => void;
+    next: () => void;
+    prev: () => void;
+    first: () => void;
+    last: () => void;
+}
+export interface UseDeckOptions {
+    /** The initial 0-based index (clamped). Default 0. */
+    initial?: number;
+    /** Fired AFTER a navigation commits, with the new + previous index. */
+    onChange?: (to: number, from: number) => void;
+    /** Resolve a per-slide accessible name for the live announcement (e.g. the
+        manifest title). When set, `liveMessage` reads "Slide N of M: <name>". */
+    label?: (index: number) => string;
+}
+export declare function useDeck(total: number, opts?: UseDeckOptions): DeckCore;

package/dist/components/custom/deck/composables/useDeckKeyboard.d.ts

@@ -0,0 +1,25 @@
+import { type MaybeRefOrGetter } from "vue";
+/** The minimal move surface the handler drives (a structural subset of DeckCore,
+    so the consumer can pass its `DeckCore` directly). */
+export interface DeckMoves {
+    next(): void;
+    prev(): void;
+    first(): void;
+    last(): void;
+    go(i: number): void;
+}
+export interface DeckKeyOptions {
+    /** Override the focused-control test (defaults to `target.closest(controls)`). */
+    isControl?: (target: EventTarget | null) => boolean;
+}
+/** Handle ONE keydown against the deck. Returns true if it navigated (and called
+    `preventDefault`), false if the key was left for the page/control. */
+export declare function handleDeckKey(e: KeyboardEvent, deck: DeckMoves, opts?: DeckKeyOptions): boolean;
+export interface UseDeckKeyboardOptions extends DeckKeyOptions {
+    /** The element the listener binds to. Default `window` (deck-global paging). */
+    target?: MaybeRefOrGetter<EventTarget | null | undefined>;
+}
+/** Bind the focus-guarded deck keyboard contract to a target (default `window`)
+    for the component lifetime. The `target` may be a ref/getter so a not-yet-mounted
+    element resolves at `onMounted`. */
+export declare function useDeckKeyboard(deck: DeckMoves, opts?: UseDeckKeyboardOptions): void;

package/dist/components/custom/deck/composables/useDeckSpring.d.ts

@@ -0,0 +1,22 @@
+/** The deck spring preset, re-exported from the colocated constants for consumers
+    sampling the same `(response, ζ)` row. */
+export { DECK_SPRING } from "../constants";
+/**
+ * Count-up easing. Defaults to a monotone cubic-out so a still render (or a failed
+ * engine chunk) is always faithful; replaced in-place with the engine's
+ * `springTimingFunction(.smooth)` once keyframes.js resolves. Callers read
+ * `deckEase.fn` each frame, so the swap is picked up live with no re-wiring.
+ */
+export declare const deckEase: {
+    fn: (t: number) => number;
+};
+/**
+ * Swap `deckEase.fn` to the engine's matching JS easing once keyframes.js resolves.
+ * Idempotent. No-op off-DOM (SSR / export tooling) and a silent no-op if the engine
+ * chunk fails — the count-up keeps its monotone cubic fallback.
+ *
+ * The slide transition needs no JS write: `--spring-deck: var(--spring-smooth)`
+ * (glass-ui's `.smooth` `linear()` token) resolves the declarative half at first
+ * paint.
+ */
+export declare function installDeckSpring(): void;

package/dist/components/custom/deck/constants.d.ts

@@ -0,0 +1,14 @@
+/** SwiftUI `.smooth` — the deck's slide-transition + count-up curve: a calm settle
+    with a barely-there micro-overshoot, the right cadence for a content deck (the
+    page change reads as a settle, not a bounce). It is the SAME family the
+    `--spring-smooth` token derives from (`springLinearStops()` output), so the deck
+    inherits the constellation's iOS curve instead of forking a third easing
+    vocabulary — `--spring-deck: var(--spring-smooth)`. */
+export declare const DECK_SPRING: {
+    readonly response: 0.5;
+    readonly dampingFraction: 0.85;
+};
+/** The focused-control selector the keyboard handler tests: when a control (button
+    / link / field) is focused, Space + digit jumps reach that control's native
+    activation instead of being stolen for navigation (the C6 correctness fix). */
+export declare const CONTROL_SELECTOR = "button, a, input, textarea, select, [role=button]";

package/dist/components/custom/deck/index.d.ts

@@ -0,0 +1,8 @@
+export { useDeck } from "./composables/useDeck";
+export type { DeckCore, UseDeckOptions } from "./composables/useDeck";
+export { useDeckKeyboard, handleDeckKey } from "./composables/useDeckKeyboard";
+export type { DeckMoves, DeckKeyOptions, UseDeckKeyboardOptions, } from "./composables/useDeckKeyboard";
+export { installDeckSpring, deckEase, DECK_SPRING, } from "./composables/useDeckSpring";
+export { default as DeckPager } from "./DeckPager.vue";
+export { CONTROL_SELECTOR } from "./constants";
+export type { PagerWindow } from "../pager-dots/pagerWindow";

package/dist/components/custom/dock/DockDropdownTrigger.vue.d.ts

@@ -3,9 +3,10 @@ import { type DropdownMenuTriggerProps } from "reka-ui";
 /**
  * <DockDropdownTrigger> — variable-width DropdownMenu trigger for use inside GlassDock.
  *
- * Emits the dock dropdown-trigger class contract. Interactive styling is owned
- * by src/styles/dock.css. Matches DockIconButton's hover-scale behaviour
- * unlike DockSelectTrigger, which doesn't scale.
+ * Emits the SHARED `.dock-trigger` recipe (BD.W-DOCK-CORE A8 — the unified dock
+ * overlay-trigger family: select/dropdown/popover are byte-identical geometry + style +
+ * baseline alignment). Interactive styling is owned by dock-controls/triggers.css; the
+ * hover-scale is OFF across the family so portaled content anchors smoothly.
  *
  * Consumers provide the button content (icon + text + optional chevron)
  * via the default slot.

package/dist/components/custom/dock/DockIconButton.vue.d.ts

@@ -22,8 +22,28 @@ import { type ButtonHTMLAttributes, type Component, type HTMLAttributes } from "
 type __VLS_Props = {
     /** Compact variant: auto-sized instead of fixed 2.5rem square. */
     compact?: boolean;
+    /**
+     * Selected/toggled state (BC.W-DOCK-ENGINE cross-repo fold — fourier-M #10).
+     * The icon button is otherwise STATELESS (hover/press only); a consumer
+     * building a selectable dock control (a filter toggle, a mode picker) had to
+     * hand-roll the active register. Setting `active` stamps `aria-pressed` (the
+     * load-bearing AT-selectable semantic) + `data-active` (the CSS hook reading
+     * the existing `--dock-control-active-bg` "selected reads as glass" tier —
+     * NEVER a saturated brand hue, per W-REGISTER-IOS). Ergonomic sugar over the
+     * shipped register; no new token, no new paint.
+     */
+    active?: boolean;
     /** Button type attribute (default: "button" to prevent form submission). */
     type?: ButtonHTMLAttributes["type"];
+    /**
+     * Disabled state (the four-state contract). A boundary nav control (a
+     * prev/next at the first/last item) stays PRESENT but disabled so the row
+     * geometry holds, never DOM-absent (the "flaky" read). On a <button> host it
+     * lands the native `disabled` attribute + `aria-disabled`; the CSS reads the
+     * `:disabled` register (the shared `.dock-icon-button:disabled` dim + the
+     * `pointer-events:none` press-suppress).
+     */
+    disabled?: boolean;
     /** Host tag/component (reka-ui Primitive `as`; default "button"). */
     as?: string | Component;
     /** Merge props onto a slotted child instead of rendering a host tag. */
@@ -35,8 +55,10 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    active: boolean;
     type: "button" | "reset" | "submit";
     compact: boolean;
+    disabled: boolean;
     asChild: boolean;
     as: string | Component;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;