@mkbabb/glass-ui 7.0.0 → 9.0.0

package/dist/components/fourier-field/shaders/render.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const FOURIER_FIELD_RENDER_WGSL = "\n// 0 chain \u00B7 1 trail \u00B7 2 head \u2014 a pipeline-overridable constant, three pipelines, one module.\noverride LAYER: i32 = 0;\n\n// THE SPLICE CONTRACT, honoured. OKLCH_MATRICES_WGSL states it at color.wgsl.ts:52-53 \u2014\n// \"PI must be in scope (the consumer defines it first, as the GLSL chunk requires)\" \u2014 and\n// spends it at :105 folding the OKLCh hue to [0, 2pi). This module splices that chunk\n// below and defined PI nowhere, so every CreateShaderModule on this source failed\n// validation with \"unresolved value 'PI'\" and the stage painted NOTHING. The two other\n// WGSL primaries carry the same line for the same reason (aurora.wgsl.ts:49,\n// metaball.wgsl.ts:53); this is that house idiom, not a local patch. The CLASS is gated\n// by tests/components/fourier-field/wgsl-splice-contract.test.ts, which resolves every\n// assembled module against the chunks it splices.\nconst PI: f32 = 3.141592653589793;\n\nconst TANGENT_EPS: f32 = 1e-4;\nconst SPEED_REF_HALFWIDTHS: f32 = 6.0;\n// The trail's taper: the mark keeps this fraction of its width at the oldest tail.\nconst TAIL_TAPER: f32 = 0.55;\n\nstruct RenderUniforms {\n  // r0: (centerX, centerY, scale, aspect)\n  r0: vec4<f32>,\n  // r1: (markHalf, inkOffsetStrokes, scaffoldFrac, edgeMargin)\n  r1: vec4<f32>,\n  // r2: (peakAlpha, glow, squash, trailFadeExp)\n  r2: vec4<f32>,\n  // r3: (trailFloor, hueSweep, ringStrokeModel, showMachine)\n  r3: vec4<f32>,\n  // ink: (linear rgb, rainbowChain)\n  ink: vec4<f32>,\n  // head: (linear rgb, _pad)\n  head: vec4<f32>,\n  // ints: (sampleCount, lutSize, chainCount, _pad)\n  ints: vec4<i32>,\n  // the CPU-resolved linear-sRGB ramp \u2014 the length is the TS constant, not a second copy\n  lut: array<vec4<f32>, 16>,\n};\n\n@group(0) @binding(0) var<uniform> u: RenderUniforms;\n@group(0) @binding(1) var<storage, read> curveSamples: array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> chainTips: array<vec4<f32>>;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Read the CPU-resolved ramp. No colour-space conversion happens here \u2014 the LUT already\n// carries the chroma floor and the gamut map.\nfn sampleRamp(t: f32) -> vec3<f32> {\n  let n = u.ints.y;\n  let ft = clamp(t, 0.0, 1.0) * f32(n - 1);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, n - 1);\n  return mix(u.lut[i0].rgb, u.lut[i1].rgb, ft - f32(i0));\n}\n\n// The chain's hue sweep, taken ONCE PER INSTANCE in the vertex stage: the ramp entry for\n// this arm, rotated about the palette anchor by \u00B1hueSweep. Anchored warm, the sweep is\n// bounded by its own arithmetic \u2014 it cannot arrive anywhere the palette is not.\nfn chainTint(seg: f32) -> vec3<f32> {\n  let base = sampleRamp(seg * 0.6);\n  if (u.ink.w < 0.5) { return base; }\n  let lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * base);\n  let lch = oklabToOklch(lab);\n  let swept = vec3<f32>(lch.x, lch.y, lch.z + mix(-u.r3.y, u.r3.y, clamp(seg, 0.0, 1.0)));\n  return oklabToLinearSrgb(oklchToOklab(swept));\n}\n\nfn segDist(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>) -> f32 {\n  let pa = p - a;\n  let ba = b - a;\n  let h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n\n// The head's travel frame + its volume-preserving anisotropic metric.\nstruct HeadFrame { T: vec2<f32>, sHat: f32, };\nfn headFrame(head: vec2<f32>, back: vec2<f32>, halfW: f32) -> HeadFrame {\n  let d = head - back;\n  let s = length(d);\n  var out: HeadFrame;\n  if (s <= TANGENT_EPS) {\n    out.T = vec2<f32>(1.0, 0.0);\n    out.sHat = 0.0;\n    return out;\n  }\n  out.T = d / s;\n  out.sHat = clamp(s / max(halfW * SPEED_REF_HALFWIDTHS, 1e-6), 0.0, 1.0);\n  return out;\n}\n\nfn headAniso(p: vec2<f32>, head: vec2<f32>, fr: HeadFrame, k: f32) -> f32 {\n  let g = 1.0 + k * fr.sHat;\n  let n = vec2<f32>(-fr.T.y, fr.T.x);\n  let rel = p - head;\n  return length(vec2<f32>(dot(rel, fr.T) / g, dot(rel, n) * g));\n}\n\nfn quadCorner(vi: u32) -> vec2<f32> {\n  var c = array<vec2<f32>, 6>(\n    vec2<f32>(0.0, 0.0), vec2<f32>(1.0, 0.0), vec2<f32>(0.0, 1.0),\n    vec2<f32>(0.0, 1.0), vec2<f32>(1.0, 0.0), vec2<f32>(1.0, 1.0),\n  );\n  return c[vi];\n}\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) p: vec2<f32>,\n  @location(1) a: vec2<f32>,\n  @location(2) b: vec2<f32>,\n  // (age, strokeHalf, drawRing)\n  @location(3) seg: vec3<f32>,\n  @location(4) @interpolate(flat) tint: vec3<f32>,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32, @builtin(instance_index) inst: u32) -> VSOut {\n  let corner = quadCorner(vi);\n  let center = u.r0.xy;\n  let scale = max(u.r0.z, 1e-6);\n  let aspect = max(u.r0.w, 1e-4);\n  let markHalf = u.r1.x;\n  let margin = u.r1.w;\n\n  var a = vec2<f32>(0.0);\n  var b = vec2<f32>(0.0);\n  var strokeHalf = markHalf;\n  var age = 0.0;\n  var drawRing = 0.0;\n  var tint = vec3<f32>(0.0);\n  var isCapsule = true;\n  var ext = markHalf;\n\n  if (LAYER == 0) {\n    // CHAIN \u2014 the AABB around this arm's own orbit (radius = |b \u2212 a| = |c_k|).\n    a = chainTips[inst].xy;\n    b = chainTips[inst + 1u].xy;\n    let radius = length(b - a);\n    // THE RING LAW, asked of the live stage: a circle narrower than its own line is a blob.\n    if (2.0 * radius >= u.r3.z) { drawRing = 1.0; }\n    strokeHalf = markHalf * u.r1.z;\n    tint = chainTint(f32(inst) / max(f32(u.ints.z) - 1.0, 1.0));\n    ext = radius + strokeHalf * 2.0;\n    isCapsule = false;\n  } else if (LAYER == 1) {\n    // TRAIL \u2014 the curve capsule, padded for the ink's own offset.\n    a = curveSamples[inst].xy;\n    b = curveSamples[inst + 1u].xy;\n    age = max(curveSamples[inst].z, curveSamples[inst + 1u].z);\n    tint = sampleRamp(1.0 - age);\n    ext = markHalf * (1.0 + 2.0 * max(u.r1.y, 0.0));\n    isCapsule = true;\n  } else {\n    // HEAD \u2014 centred on the newest curve sample; the AABB is the halo.\n    a = curveSamples[0].xy;\n    b = curveSamples[1].xy;\n    tint = u.head.rgb;\n    ext = markHalf * 5.0;\n    isCapsule = false;\n  }\n  ext = ext + margin;\n\n  var pos: vec2<f32>;\n  if (isCapsule) {\n    let d = b - a;\n    let len = length(d);\n    var dir = vec2<f32>(1.0, 0.0);\n    if (len > 1e-6) { dir = d / len; }\n    let perp = vec2<f32>(-dir.y, dir.x);\n    pos = mix(a - dir * ext, b + dir * ext, corner.x) + perp * (corner.y * 2.0 - 1.0) * ext;\n  } else {\n    pos = a + (corner * 2.0 - vec2<f32>(1.0)) * ext;\n  }\n\n  var out: VSOut;\n  out.pos = vec4<f32>((pos.x - center.x) * scale / aspect, (pos.y - center.y) * scale, 0.0, 1.0);\n  out.p = pos;\n  out.a = a;\n  out.b = b;\n  out.seg = vec3<f32>(age, strokeHalf, drawRing);\n  out.tint = tint;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let p = in.p;\n  let aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;\n  let peak = u.r2.x;\n  let glow = u.r2.y;\n  let squash = u.r2.z;\n  let fadeExp = u.r2.w;\n  let trailFloor = u.r3.x;\n  let markHalf = u.r1.x;\n  let strokeHalf = in.seg.y;\n  let age = in.seg.x;\n  let a = in.a;\n  let b = in.b;\n\n  if (LAYER == 0) {\n    // \u2500\u2500 THE MACHINE \u2014 ring (conditionally), arm, joint dot; one scaffold rung \u2500\u2500\n    let radius = length(b - a);\n    var m = 0.0;\n    if (in.seg.z > 0.5) {\n      let dRing = abs(length(p - a) - radius);\n      m = max(m, 1.0 - smoothstep(strokeHalf, strokeHalf + aa, dRing));\n    }\n    m = max(m, 1.0 - smoothstep(strokeHalf, strokeHalf + aa, segDist(p, a, b)));\n    // The joint dot is the mark's own diameter \u2014 the machine's one solid rung.\n    m = max(m, 1.0 - smoothstep(markHalf, markHalf + aa, length(p - a)));\n    let alpha = clamp(m, 0.0, 1.0) * peak;\n    let rgb = clamp(linearToSrgb(in.tint), vec3<f32>(0.0), vec3<f32>(1.0));\n    return vec4<f32>(rgb * alpha, alpha);\n  } else if (LAYER == 1) {\n    // \u2500\u2500 THE CURVE \u2014 ink under mark, composited at \u03B11, then ONE envelope \u2500\u2500\n    let taper = TAIL_TAPER + (1.0 - TAIL_TAPER) * age;\n    let half = markHalf * taper;\n    // The ink rides THIS segment's own tangent, opposite the travel: the head runs from\n    // b toward a, so the ink lands behind at (b \u2212 a).\n    var dir = vec2<f32>(1.0, 0.0);\n    let d = b - a;\n    let len = length(d);\n    if (len > 1e-6) { dir = d / len; }\n    let off = dir * (markHalf * 2.0 * u.r1.y);\n\n    let aMark = 1.0 - smoothstep(half, half + aa, segDist(p, a, b));\n    let aInk = 1.0 - smoothstep(half, half + aa, segDist(p, a + off, b + off));\n\n    let markRgb = clamp(linearToSrgb(in.tint), vec3<f32>(0.0), vec3<f32>(1.0));\n    let inkRgb = clamp(linearToSrgb(u.ink.rgb), vec3<f32>(0.0), vec3<f32>(1.0));\n\n    // Mark OVER ink, both fully opaque where they cover \u2014 the pair, then the envelope.\n    let aPair = aMark + aInk * (1.0 - aMark);\n    let rgbPair = markRgb * aMark + inkRgb * aInk * (1.0 - aMark);\n    let env = peak * max(pow(max(age, 0.0), fadeExp), trailFloor);\n    return vec4<f32>(rgbPair * env, aPair * env);\n  } else {\n    // \u2500\u2500 THE HEAD \u2014 palette-lifted core over its own halo. Light-led, never white. \u2500\u2500\n    let fr = headFrame(a, b, markHalf);\n    let dHead = headAniso(p, a, fr, squash);\n    let coreR = markHalf * 1.5;\n    let haloR = coreR * 3.0;\n    let rgb = clamp(linearToSrgb(in.tint), vec3<f32>(0.0), vec3<f32>(1.0));\n    let halo = (1.0 - smoothstep(0.0, haloR, dHead)) * glow;\n    let core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * peak;\n    let alpha = clamp(max(core, halo), 0.0, 1.0);\n    return vec4<f32>(rgb * alpha, alpha);\n  }\n}\n";

package/dist/components/fourier-field/useFourierField.d.ts

@@ -0,0 +1,49 @@
+import { type Ref } from "vue";
+import { type GpuBackend, type RendererStatus } from "../../composables/glass/webgpu/useGpuSubstrate.js";
+import type { OklchStop } from "../../composables/color/index.js";
+import { type FourierFieldConfig } from "./constants.js";
+import type { MintedSpectrum } from "./renderer/mint.js";
+export interface UseFourierFieldOptions {
+    config: FourierFieldConfig;
+    /** The minted spectrum (identity-stable until the source or seed changes). */
+    getSpectrum: () => MintedSpectrum;
+    /** The resolved palette stops as OKLCh. */
+    getPalette: () => OklchStop[];
+    /**
+     * Whether the pointer drives the clock. ONE authority — the component's own
+     * `interactive` prop — read live rather than copied into the config.
+     */
+    interactive: () => boolean;
+    /** Hold the clock at its current parameter and never advance. */
+    freeze?: () => boolean;
+    /** `"capture"` → renderAt-only (the deterministic capture path). Default `"live"`. */
+    mode?: "live" | "capture";
+}
+/** The handle a consumer wires its lifecycle and its transport against. */
+export interface FourierFieldHandle {
+    /** The resolved backend. Always `"webgpu"` where the field paints at all. */
+    readonly backend: GpuBackend;
+    /** Park the loop (the pause seam). */
+    pause: () => void;
+    /** Re-arm the loop. */
+    resume: () => void;
+    /** Re-arm a parked loop on demand. */
+    wake: () => void;
+    /** The live `prefers-reduced-motion: reduce` state. */
+    readonly reducedMotion: boolean;
+    /** The current loop parameter `head_t ∈ [0,1)`. */
+    readonly headT: number;
+    /**
+     * The same parameter as a REACTIVE read, refreshed off the one clock at a rate a
+     * reader (or a screen reader) can follow. It is a sample of the frame loop, never a
+     * second one.
+     */
+    readonly headTLive: Readonly<Ref<number>>;
+    readonly rendererStatus: Readonly<Ref<RendererStatus>>;
+    /** Scrub the clock directly. Takes no spring — a hand's position is not a physics event. */
+    setHeadT: (t: number) => void;
+    /** Inject one flick impulse, in turns per second. Capped and floored like any other. */
+    flick: (turnsPerSec: number) => void;
+    dispose: () => void;
+}
+export declare function useFourierField(canvasRef: Ref<HTMLCanvasElement | null>, options: UseFourierFieldOptions): FourierFieldHandle;

package/dist/components/handmark/HandMark.vue.d.ts

@@ -1,23 +1,27 @@
-import type { HandMarkProps } from "./types";
+import { type HandShape } from "./stroke.js";
+type __VLS_Props = {
+    shape?: HandShape;
+    color?: string;
+    weight?: number;
+    seed?: number;
+    draw?: boolean;
+};
 declare function play(): void;
-declare var __VLS_1: {};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<HandMarkProps, {
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     play: typeof play;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HandMarkProps> & Readonly<{}>, {
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     color: string;
-    seed: number;
-    shape: import("./types").HandShape;
-    animation: import("./types").HandAnimation;
-    jagged: boolean;
-    brush: import("./brush").BrushName | Partial<import("./brush").Brush>;
-    drawMs: number;
-    drawDelayMs: number;
-    appear: "mount" | "visible" | "manual";
-    boilFps: number;
-    boilFrames: number;
+    shape: HandShape;
+    weight: number;
+    draw: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

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

@@ -1,24 +1,7 @@
 /**
- * HandMark public barrel.
- * ─────────────────────────────────────────────────────────────────────────────
- * `HandMark` is the sole public component name. The pure L1–L3 functions ship
- * too — they are framework-free, directly usable in slides decks, D3 charts
- * (call `shapeGeom`/`ellipsePoints` to ink a path), even canvas.
- *
- * The DEFAULT is `pen` (clean ink, grain:0 ⇒ no filter, zero extra dep). The
- * `@mkbabb/pencil-boil` geometry is an OPTIONAL PEER. The perfect-freehand body
- * is vendored; only `ribbon:'hull'` (the highlighter) touches that core
- * (treeshaken otherwise).
- *
- * The editorial draw-on underline is
- * `<HandMark shape="underline" animation="draw-on">`; the natural pencil-boil
- * morphology is the `boil` brush.
+ * HandMark public barrel. The component is the surface; the pure functions ship with
+ * it so a caller who owns its own path can ink it with the same pen — `strokeRibbon`
+ * takes any polyline.
  */
-export { default as HandMark } from "./HandMark.vue";
-export { BRUSHES, resolveBrush, lerpBrush, type Brush, type BrushName, type BlendMode, type TaperSpec, type StampFn, type InkPath, } from "./brush";
-export { shapeGeom, serialize, boilLines, naturalUnderlinePoints, VB_W, VB_H, UNDERLINE_GAP, type ShapeGeom, } from "./geometry";
-export { ink, type SVGFragment } from "./ink";
-export { grainFilter, hasGrain } from "./texture";
-export { getStroke, getStrokePoints, getSvgPathFromStroke, type StrokeOptions, type InputPoint, } from "./freehand";
-export { useHandMark, normalizeProps, type UseHandMarkInput, type HandMarkCore, type BoilClock, } from "./composables/useHandMark";
-export type { HandMarkProps, HandShape, HandAnimation, MarkBox, } from "./types";
+export { default as HandMark } from "./HandMark.vue.js";
+export { SHAPES, handBand, handLine, handRing, markDuration, minJerk, serialize, strokeRibbon, type Frame, type HandShape, type Point, } from "./stroke.js";

package/dist/components/handmark/stroke.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The hand voice — one pen, five laws, no framework.
+ *
+ * Every function here is pure and framework-free: a caller with a rect and a font
+ * size gets the same geometry the component draws, in 1:1 CSS pixels. `strokeRibbon`
+ * takes ANY polyline, so a consumer that owns its own path (a chart leader, a route)
+ * inks it with this pen rather than re-deriving one.
+ */
+/** The four gestures, enumerated at runtime so a member change breaks compile-visibly. */
+export declare const SHAPES: readonly ["underline", "strike", "circle", "highlight"];
+export type HandShape = (typeof SHAPES)[number];
+export interface Point {
+    x: number;
+    y: number;
+}
+/** A measured text rect, in CSS px, already expressed in the frame that draws it. */
+export interface Frame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare const CAP_HEIGHT = 0.7515;
+/** L4 — x-height plus a 0.04em bleed at each end. */
+export declare const BAND_HEIGHT: number;
+/**
+ * The hand's outer envelope for the ring, in em: the declared vertical run 2b carried
+ * out by the largest radial creep and the largest wobble crest it admits.
+ */
+export declare const RING_ENVELOPE: number;
+/** L1 — the clampless allometric nib. `weight` is a dimensionless multiple. */
+export declare function nib(weight: number, fs: number): number;
+/** L3 — floorless, ceilingless pace over the path length of ONE line rect. */
+export declare function markDuration(length: number): number;
+/**
+ * The minimum-jerk draw profile as a CSS `linear()` easing.
+ *
+ * Every stop is emitted the same way — the PROFILE'S OWN VALUE at its own input — so
+ * `easing(0) = 0` and `easing(1) = 1` hold by construction: `10t³ − 15t⁴ + 6t⁵` is
+ * exactly 0 and exactly 1 at those ends. There is no endpoint special case, because an
+ * endpoint special case is a second expression for a quantity the loop already has,
+ * and the two can disagree. (They did: the branch it replaces emitted the loop INDEX,
+ * so `easing(1)` was `samples` and a draw animating `stroke-dashoffset` to 0 with
+ * `fill: both` came to rest at −23 dash periods — a mark inside its own gap.)
+ */
+export declare function minJerk(samples?: number): string;
+export interface LineOpts {
+    fs: number;
+    seed: number;
+    kind: "underline" | "strike";
+}
+/**
+ * L2 — the centreline. `d(u) = S·[4u(1−u) + B·4u(1−u)(1−2u)]` with |B| ≤ 0.4: both
+ * modes vanish at the endpoints and `d′` is a quadratic, so the commit carries at most
+ * two extrema in closed form for every seed. The lift-off hook is monotone in t over
+ * the last 6% and belongs to the release, never to the calm reading. Tilt is a shear,
+ * not a rotation, so the per-end reach stays exactly what the run-out declares.
+ */
+export declare function handLine(rect: Frame, o: LineOpts): Point[];
+/** The ring's semi-axes: the exact curve through the padded box corner on BOTH axes. */
+export declare function ringAxes(rect: Frame, fs: number): {
+    a: number;
+    b: number;
+};
+/** The horizontal overshoot a ring reserves with `padding-inline` on its wrapper. */
+export declare function ringReserve(rect: Frame, fs: number): number;
+/** L2-RING — an n=3 superellipse, overswept so the tail closes outside the head. */
+export declare function handRing(rect: Frame, o: {
+    fs: number;
+    seed: number;
+}): Point[];
+/**
+ * L4 — the band: one chisel per line rect, raked at both ends, sagging like a swipe,
+ * overrunning its word by 1–2% a side. Opaque, and it carries no ink colour: the page's
+ * own foreground reads on it in both themes.
+ */
+export declare function handBand(rect: Frame, o: {
+    fs: number;
+    seed: number;
+}): Point[];
+/** `M x y L x y …` over an open polyline. */
+export declare function serialize(points: Point[]): string;
+/**
+ * The pen, over an arbitrary polyline: the ribbon is the outline of a stroke of
+ * maximum width `w`, emitted left side forward then right side back, so the minor axis
+ * at any sample is the nib the eye reads there.
+ */
+export declare function strokeRibbon(points: Point[], w: number): string;
+/** A closed polygon — the band's own emission, which is a fill and not a stroke. */
+export declare function fillPolygon(points: Point[]): string;
+/** The default seed: the marked text, salted by the mark's position among its siblings. */
+export declare function markSeed(text: string, instanceIndex: number): number;

package/dist/components/index.d.ts

@@ -1,32 +1,30 @@
-export * from "./accordion";
-export * from "./alert";
-export * from "./avatar";
-export * from "./badge";
-export * from "./button";
-export * from "./card";
-export * from "./carousel";
-export * from "./checkbox";
-export * from "./collapsible";
-export * from "./combobox";
-export * from "./command";
-export * from "./data-table";
-export * from "./dialog";
-export * from "./drawer";
-export * from "./dropdown-menu";
-export * from "./input";
-export * from "./label";
-export * from "./number-field";
-export * from "./popover";
-export * from "./progress";
-export * from "./radio-group";
-export * from "./select";
-export * from "./separator";
-export * from "./skeleton";
-export * from "./slider";
-export * from "./switch";
-export * from "./table";
-export * from "./tags-input";
-export * from "./textarea";
-export * from "./toast";
-export * from "./toggle-group";
-export * from "./tooltip";
+export * from "./accordion/index.js";
+export * from "./alert/index.js";
+export * from "./avatar/index.js";
+export * from "./badge/index.js";
+export * from "./button/index.js";
+export * from "./card/index.js";
+export * from "./carousel/index.js";
+export * from "./checkbox/index.js";
+export * from "./collapsible/index.js";
+export * from "./command/index.js";
+export * from "./data-table/index.js";
+export * from "./dialog/index.js";
+export * from "./menu/index.js";
+export * from "./input/index.js";
+export * from "./label/index.js";
+export * from "./number-field/index.js";
+export * from "./popover/index.js";
+export * from "./progress/index.js";
+export * from "./radio-group/index.js";
+export * from "./select/index.js";
+export * from "./separator/index.js";
+export * from "./sheet/index.js";
+export * from "./skeleton/index.js";
+export * from "./slider/index.js";
+export * from "./switch/index.js";
+export * from "./table/index.js";
+export * from "./textarea/index.js";
+export * from "./toast/index.js";
+export * from "./toggle-group/index.js";
+export * from "./tooltip/index.js";

package/dist/components/infinite-scroll/InfiniteScroll.vue.d.ts

@@ -6,13 +6,13 @@ type __VLS_Props = {
     /** Distance from bottom to trigger (px) */
     threshold?: number;
 };
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+declare var __VLS_1: {}, __VLS_9: {}, __VLS_16: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 } & {
-    loading?: (props: typeof __VLS_3) => any;
+    loading?: (props: typeof __VLS_9) => any;
 } & {
-    end?: (props: typeof __VLS_5) => any;
+    end?: (props: typeof __VLS_16) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     sentinelRef: import("vue").Ref<HTMLElement | null, HTMLElement | null>;

package/dist/components/infinite-scroll/composables/index.d.ts

@@ -1,2 +1,2 @@
-export { useInfiniteScroll } from "./useInfiniteScroll";
-export type { InfiniteScrollOptions, InfiniteScrollReturn } from "./types";
+export { useInfiniteScroll } from "./useInfiniteScroll.js";
+export type { InfiniteScrollOptions, InfiniteScrollReturn } from "./types.js";

package/dist/components/infinite-scroll/composables/useInfiniteScroll.d.ts

@@ -1,4 +1,4 @@
-import type { InfiniteScrollOptions, InfiniteScrollReturn } from "./types";
+import type { InfiniteScrollOptions, InfiniteScrollReturn } from "./types.js";
 /**
  * Composable for infinite scroll with IntersectionObserver.
  *

package/dist/components/infinite-scroll/index.d.ts

@@ -1,2 +1,2 @@
-export { default as InfiniteScroll } from "./InfiniteScroll.vue";
-export * from "./composables";
+export { default as InfiniteScroll } from "./InfiniteScroll.vue.js";
+export * from "./composables/index.js";

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

@@ -1,12 +1,17 @@
-import type { InputProps } from "./types";
-declare const __VLS_export: import("vue").DefineComponent<InputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+import type { InputProps } from "./types.js";
+type __VLS_Props = InputProps;
+type __VLS_ModelProps = {
+    modelValue?: string | number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: string | number) => any;
-}, string, import("vue").PublicProps, Readonly<InputProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
 }>, {
-    size: import("../_shared").ControlSize;
+    size: import(".").ControlSize;
+    type: "date" | "datetime-local" | "email" | "month" | "password" | "search" | "tel" | "text" | "time" | "url" | "week";
     invalid: boolean;
-    type: "email" | "password" | "search" | "tel" | "text" | "url";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,2 +1,3 @@
-export { default as Input } from "./Input.vue";
-export type { InputProps } from "./types";
+export { default as Input } from "./Input.vue.js";
+export type { InputNativeAttrs, InputProps } from "./types.js";
+export type { ControlSize } from "../_shared/control.js";

package/dist/components/input/types.d.ts

@@ -1,22 +1,62 @@
 import type { HTMLAttributes, InputHTMLAttributes } from "vue";
-import type { ControlSize } from "../_shared/control-size";
-export interface InputProps {
+import type { ControlSize } from "../_shared/control.js";
+/**
+ * The native form/constraint surface — TYPED for the caller, and NOT a runtime
+ * prop. The `/* @vue-ignore *\/` on the extends clause below is the whole
+ * mechanism: `vue-tsc` sees these, `defineProps` does not, so every one of them
+ * rides `$attrs` to the element and the component never re-binds a single one.
+ *
+ * What died with it: a 15-line `nativeProps` computed that re-declared these as
+ * props and then hand-copied them back onto the element — an over-declaration
+ * `inheritAttrs: false` forced into existence, and a list that had to be extended
+ * by hand every time the platform was found to have an attribute nobody had
+ * transcribed yet.
+ *
+ * The whole `InputHTMLAttributes` is deliberately NOT the base: its 225 members
+ * blow the props union past `tsc`'s complexity bound (TS2590, measured) and drag
+ * in `hidden`/`width`/`height` overloads that collide with `ComponentCustomProps`.
+ * A text field's real native surface is this.
+ */
+export interface InputNativeAttrs {
     autocomplete?: string;
-    class?: HTMLAttributes["class"];
-    defaultValue?: string | number;
-    disabled?: boolean;
     enterkeyhint?: InputHTMLAttributes["enterkeyhint"];
     form?: string;
     inputmode?: InputHTMLAttributes["inputmode"];
-    invalid?: boolean;
+    list?: string;
+    max?: InputHTMLAttributes["max"];
     maxlength?: InputHTMLAttributes["maxlength"];
+    min?: InputHTMLAttributes["min"];
     minlength?: InputHTMLAttributes["minlength"];
-    modelValue?: string | number;
     name?: string;
     pattern?: string;
     placeholder?: string;
-    readonly?: boolean;
     required?: boolean;
+    step?: InputHTMLAttributes["step"];
+}
+export interface InputProps extends /* @vue-ignore */ InputNativeAttrs {
+    class?: HTMLAttributes["class"];
+    /** Feeds the one state machine (`data-state`), so it is a prop, not an attr. */
+    disabled?: boolean;
+    /** App-driven validity. Native constraint validation and a bare
+     *  `aria-invalid` reach the same one grammar without it. */
+    invalid?: boolean;
+    modelValue?: string | number;
+    /** Feeds the one state machine (`data-state`), so it is a prop, not an attr. */
+    readonly?: boolean;
     size?: ControlSize;
-    type?: "email" | "password" | "search" | "tel" | "text" | "url";
+    /**
+     * TEXT-SHAPED natives only, and the fence is the design.
+     *
+     * `number` is Reka's NumberField (locale parse/format + a spinbutton);
+     * `range` is Slider's geometry; `file` and `color` are non-text chrome this
+     * register would paint absurdly; `hidden` never paints at all. The five
+     * temporal values ARE text-shaped — they carry a caret, a placeholder and a
+     * text baseline — and were a genuine typed hole, so they are in.
+     *
+     * Every other native input attribute (`autocomplete`, `form`, `maxlength`,
+     * `minlength`, `name`, `pattern`, `placeholder`, `required`, `inputmode`,
+     * `enterkeyhint`, …) is UNDECLARED on purpose: it rides `$attrs` to the
+     * element, which is what the platform already does correctly.
+     */
+    type?: "date" | "datetime-local" | "email" | "month" | "password" | "search" | "tel" | "text" | "time" | "url" | "week";
 }

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

@@ -1 +1 @@
-export { default as Label, type LabelProps, type LabelRequirement, } from "./Label.vue";
+export { default as Label, type LabelProps, type LabelRequirement, } from "./Label.vue.js";

package/dist/components/labeled-field/LabeledField.vue.d.ts

@@ -1,14 +1,14 @@
-import type { LabeledFieldProps, LabeledFieldSlotProps } from "./types";
+import type { LabeledFieldProps, LabeledFieldSlotProps } from "./types.js";
 type __VLS_Slots = {
     default(props: LabeledFieldSlotProps): unknown;
     error?(): unknown;
 };
 declare const __VLS_base: import("vue").DefineComponent<LabeledFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LabeledFieldProps> & Readonly<{}>, {
-    invalid: boolean;
     disabled: boolean;
-    layout: import("./types").LabeledFieldLayout;
+    layout: import("./types.js").LabeledFieldLayout;
+    invalid: boolean;
     controlLabelable: boolean;
-    errorLive: import("./types").LabeledFieldErrorLive;
+    errorLive: import("./types.js").LabeledFieldErrorLive;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/labeled-field/LabeledInput.vue.d.ts

@@ -1,4 +1,4 @@
-import type { LabeledInputProps } from "./types";
+import type { LabeledInputProps } from "./types.js";
 declare var __VLS_17: {};
 type __VLS_Slots = {} & {
     error?: (props: typeof __VLS_17) => any;

package/dist/components/labeled-field/LabeledSlider.vue.d.ts

@@ -1,4 +1,4 @@
-import type { LabeledSliderProps } from "./types";
+import type { LabeledSliderProps } from "./types.js";
 declare var __VLS_17: {};
 type __VLS_Slots = {} & {
     error?: (props: typeof __VLS_17) => any;

package/dist/components/labeled-field/LabeledSwitch.vue.d.ts

@@ -1,4 +1,4 @@
-import type { LabeledSwitchProps } from "./types";
+import type { LabeledSwitchProps } from "./types.js";
 declare var __VLS_17: {};
 type __VLS_Slots = {} & {
     error?: (props: typeof __VLS_17) => any;

package/dist/components/labeled-field/index.d.ts

@@ -1,6 +1,5 @@
-export { default as LabeledField } from "./LabeledField.vue";
-export { default as LabeledInput } from "./LabeledInput.vue";
-export { default as LabeledSelect } from "./LabeledSelect.vue";
-export { default as LabeledSlider } from "./LabeledSlider.vue";
-export { default as LabeledSwitch } from "./LabeledSwitch.vue";
-export type { LabeledFieldCommonProps, LabeledFieldErrorLive, LabeledFieldLayout, LabeledFieldProps, LabeledFieldSlotProps, LabeledInputProps, LabeledSelectProps, LabeledSliderProps, LabeledSwitchProps, } from "./types";
+export { default as LabeledField } from "./LabeledField.vue.js";
+export { default as LabeledInput } from "./LabeledInput.vue.js";
+export { default as LabeledSlider } from "./LabeledSlider.vue.js";
+export { default as LabeledSwitch } from "./LabeledSwitch.vue.js";
+export type { LabeledFieldCommonProps, LabeledFieldErrorLive, LabeledFieldLayout, LabeledFieldProps, LabeledFieldSlotProps, LabeledInputProps, LabeledSliderProps, LabeledSwitchProps, } from "./types.js";

package/dist/components/labeled-field/types.d.ts

@@ -1,7 +1,7 @@
-import type { InputProps } from "../input";
-import type { LabelRequirement } from "../label";
-import type { SliderProps } from "../slider";
-import type { SwitchProps } from "../switch";
+import type { InputNativeAttrs, InputProps } from "../input/index.js";
+import type { LabelRequirement } from "../label/index.js";
+import type { SliderProps } from "../slider/index.js";
+import type { SwitchProps } from "../switch/index.js";
 export type LabeledFieldLayout = "default" | "horizontal";
 export type LabeledFieldErrorLive = "off" | "polite" | "assertive";
 export interface LabeledFieldCommonProps {
@@ -32,16 +32,7 @@ export interface LabeledFieldSlotProps {
     disabled: boolean;
     required: boolean;
 }
-export type LabeledInputProps = Omit<InputProps, "class"> & LabeledFieldCommonProps;
-export interface LabeledSelectProps extends LabeledFieldCommonProps {
-    modelValue: string;
-    items: readonly string[];
-    open?: boolean;
-    placeholder?: string;
-    invalid?: boolean;
-    disabled?: boolean;
-    required?: boolean;
-}
+export type LabeledInputProps = Omit<InputProps, "class"> & InputNativeAttrs & LabeledFieldCommonProps;
 export type LabeledSliderProps = Omit<SliderProps, "class" | "modelValue"> & LabeledFieldCommonProps & {
     modelValue: number;
 };

package/dist/components/{dropdown-menu → menu}/DropdownMenu.vue.d.ts

@@ -1,5 +1,5 @@
-import type { Direction } from "../_shared/primitive";
-import type { MenuTrigger } from "./useMenuTrigger";
+import type { Direction } from "../_shared/primitive.js";
+import type { MenuTrigger } from "./context.js";
 interface DropdownMenuBaseProps {
     /** Logical reading direction for roving focus and submenu keys. */
     dir?: Direction;

package/dist/components/{dropdown-menu → menu}/DropdownMenuCheckboxItem.vue.d.ts

@@ -1,5 +1,5 @@
 import { type HTMLAttributes } from "vue";
-import type { CheckedState } from "../_shared/selection";
+import type { CheckedState } from "../_shared/selection.js";
 export interface DropdownMenuCheckboxItemProps {
     modelValue?: CheckedState;
     disabled?: boolean;
@@ -20,8 +20,8 @@ declare const __VLS_base: import("vue").DefineComponent<DropdownMenuCheckboxItem
     onSelect?: ((event: Event) => any) | undefined;
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
 }>, {
-    disabled: boolean;
     modelValue: CheckedState;
+    disabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/{dropdown-menu → menu}/DropdownMenuContent.vue.d.ts

@@ -1,10 +1,8 @@
 import { type HTMLAttributes } from "vue";
-import type { Surface } from "../_shared/axes";
-import type { FloatingPlacementProps } from "../_shared/floating";
-import type { FocusOutsideEvent, PointerDownOutsideEvent } from "../_shared/interaction";
+import type { FocusOutsideEvent, PointerDownOutsideEvent } from "../_shared/interaction.js";
+import { type FloatingPlacementProps } from "../_shared/overlay/index.js";
 export interface DropdownMenuContentProps extends FloatingPlacementProps {
     class?: HTMLAttributes["class"];
-    surface?: Surface;
 }
 export interface DropdownMenuContentEmits {
     escapeKeyDown: [event: KeyboardEvent];
@@ -29,11 +27,10 @@ declare const __VLS_base: import("vue").DefineComponent<DropdownMenuContentProps
     onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
 }>, {
-    side: import("../_shared/floating").FloatingSide;
+    align: import("../_shared/overlay/index.js").FloatingAlign;
+    side: import("../_shared/overlay/index.js").FloatingSide;
     sideOffset: number;
-    align: import("../_shared/floating").FloatingAlign;
     alignOffset: number;
-    surface: Surface;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/{dropdown-menu → menu}/DropdownMenuRadioGroup.vue.d.ts

@@ -1,5 +1,5 @@
 import { type HTMLAttributes } from "vue";
-import type { SelectionValue } from "../_shared/selection";
+import type { SelectionValue } from "../_shared/selection.js";
 export interface DropdownMenuRadioGroupProps {
     modelValue?: SelectionValue;
     class?: HTMLAttributes["class"];

package/dist/components/{dropdown-menu → menu}/DropdownMenuRadioItem.vue.d.ts

@@ -1,5 +1,5 @@
 import { type HTMLAttributes } from "vue";
-import type { SelectionValue } from "../_shared/selection";
+import type { SelectionValue } from "../_shared/selection.js";
 export interface DropdownMenuRadioItemProps {
     value: SelectionValue;
     disabled?: boolean;