@atmos.build/ui 0.1.0

package/dist/components/provenance-chip.js

@@ -0,0 +1,17 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+import { Grid3x3, Mic, Sparkles } from 'lucide-react';
+import { cn } from '../lib/cn.js';
+import { ConfidenceMeter } from './confidence-meter.js';
+const METHOD_ICON = { dtmf: Grid3x3, deterministic: Mic, llm: Sparkles };
+export function ProvenanceChip({ method, label, raw, rawLabel, expandLabel, confidence, confidenceLabel, className, ...props }) {
+    const [expanded, setExpanded] = React.useState(false);
+    const Icon = METHOD_ICON[method];
+    const rawText = raw?.trim() || '';
+    const hasRaw = rawText.length > 0;
+    const hasConfidence = typeof confidence === 'number' && Number.isFinite(confidence);
+    const chipInner = _jsxs(_Fragment, { children: [_jsx(Icon, { className: "size-3 shrink-0", strokeWidth: 1.5, "aria-hidden": true }), _jsx("span", { className: "truncate", children: label })] });
+    const chipClass = cn('inline-flex h-5 items-center gap-1 rounded-md border border-border/60 bg-muted/40 px-1.5 text-[10.5px] font-medium text-muted-foreground', hasRaw && 'cursor-pointer outline-none transition-colors hover:border-border hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring/50');
+    return (_jsxs("span", { "data-slot": "provenance-chip", "data-method": method, className: cn('inline-flex flex-col items-start gap-1', className), ...props, children: [_jsxs("span", { className: "inline-flex flex-wrap items-center gap-1.5", children: [hasRaw ? _jsx("button", { type: "button", onClick: () => setExpanded((value) => !value), "aria-expanded": expanded, "aria-label": expandLabel ?? label, title: rawLabel ? `${rawLabel}: ${rawText}` : rawText, className: chipClass, children: chipInner }) : _jsx("span", { className: chipClass, children: chipInner }), hasConfidence ? _jsx(ConfidenceMeter, { value: confidence, label: confidenceLabel ?? label, showValue: true }) : null] }), hasRaw && expanded ? _jsxs("span", { className: "max-w-full rounded-md border border-border/50 bg-background/60 px-2 py-1 text-[11px] leading-relaxed text-muted-foreground", children: [rawLabel ? _jsxs("span", { className: "mr-1 text-muted-foreground/60", children: [rawLabel, ":"] }) : null, _jsx("span", { className: "break-words whitespace-pre-wrap text-foreground/80", children: rawText })] }) : null] }));
+}

package/dist/components/qr-code.d.ts

@@ -0,0 +1,13 @@
+export interface QrCodeProps {
+    value: string;
+    size?: number;
+    margin?: number;
+    level?: 'L' | 'M' | 'Q' | 'H';
+    foreground?: string;
+    background?: string;
+    title?: string;
+    className?: string;
+}
+export declare function qrSvgMarkup(value: string, { size, margin, level, foreground, background, title }?: Omit<QrCodeProps, 'value' | 'className'>): string;
+export declare function qrPngDataUrl(value: string, options?: Omit<QrCodeProps, 'value' | 'className'>): Promise<string>;
+export declare function QrCode({ value, size, margin, level, foreground, background, title, className }: QrCodeProps): import("react").JSX.Element;

package/dist/components/qr-code.js

@@ -0,0 +1,42 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { cn } from '../lib/cn.js';
+import { encodeQr } from './qr-encode.js';
+export function qrSvgMarkup(value, { size = 200, margin = 4, level = 'M', foreground = '#0a0a0a', background = '#ffffff', title } = {}) {
+    const matrix = encodeQr(value, level);
+    const dimension = matrix.length + margin * 2;
+    const modules = matrix.flatMap((row, y) => row.flatMap((filled, x) => filled ? [`<rect x="${x + margin}" y="${y + margin}" width="1" height="1"/>`] : [])).join('');
+    const accessibleTitle = title ? `<title>${escapeXml(title)}</title>` : '';
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${dimension} ${dimension}" shape-rendering="crispEdges" role="img"${title ? ` aria-label="${escapeXml(title)}"` : ''}>${accessibleTitle}<rect width="${dimension}" height="${dimension}" fill="${escapeXml(background)}"/><g fill="${escapeXml(foreground)}">${modules}</g></svg>`;
+}
+export function qrPngDataUrl(value, options = {}) {
+    const size = options.size ?? 512;
+    const url = URL.createObjectURL(new Blob([qrSvgMarkup(value, { ...options, size })], { type: 'image/svg+xml;charset=utf-8' }));
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.onload = () => {
+            const canvas = document.createElement('canvas');
+            canvas.width = size;
+            canvas.height = size;
+            const context = canvas.getContext('2d');
+            if (!context) {
+                URL.revokeObjectURL(url);
+                reject(new Error('canvas unavailable'));
+                return;
+            }
+            context.drawImage(image, 0, 0, size, size);
+            URL.revokeObjectURL(url);
+            resolve(canvas.toDataURL('image/png'));
+        };
+        image.onerror = () => { URL.revokeObjectURL(url); reject(new Error('qr render failed')); };
+        image.src = url;
+    });
+}
+export function QrCode({ value, size = 200, margin = 4, level = 'M', foreground = '#0a0a0a', background = '#ffffff', title, className }) {
+    const markup = useMemo(() => qrSvgMarkup(value, { size, margin, level, foreground, background, title }), [background, foreground, level, margin, size, title, value]);
+    return _jsx("span", { className: cn('inline-block leading-none', className), dangerouslySetInnerHTML: { __html: markup } });
+}
+function escapeXml(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}

package/dist/components/qr-encode.d.ts

@@ -0,0 +1,2 @@
+export type EcLevel = 'L' | 'M' | 'Q' | 'H';
+export declare function encodeQr(text: string, level?: EcLevel): boolean[][];

package/dist/components/qr-encode.js

@@ -0,0 +1,469 @@
+const EXP = new Uint8Array(512);
+const LOG = new Uint8Array(256);
+(() => {
+    let x = 1;
+    for (let i = 0; i < 255; i++) {
+        EXP[i] = x;
+        LOG[x] = i;
+        x <<= 1;
+        if (x & 0x100)
+            x ^= 0x11d;
+    }
+    for (let i = 255; i < 512; i++)
+        EXP[i] = EXP[i - 255];
+})();
+function gfMul(a, b) {
+    if (a === 0 || b === 0)
+        return 0;
+    return EXP[LOG[a] + LOG[b]];
+}
+function rsGenerator(degree) {
+    let poly = [1];
+    for (let i = 0; i < degree; i++) {
+        const next = new Array(poly.length + 1).fill(0);
+        for (let j = 0; j < poly.length; j++) {
+            const pj = poly[j];
+            next[j] = next[j] ^ pj;
+            next[j + 1] = next[j + 1] ^ gfMul(pj, EXP[i]);
+        }
+        poly = next;
+    }
+    return poly;
+}
+function rsEncode(data, degree) {
+    const gen = rsGenerator(degree);
+    const res = new Array(degree).fill(0);
+    for (const d of data) {
+        const factor = d ^ res[0];
+        res.shift();
+        res.push(0);
+        for (let i = 0; i < gen.length - 1; i++) {
+            res[i] = res[i] ^ gfMul(gen[i + 1], factor);
+        }
+    }
+    return res;
+}
+// prettier-ignore
+const EC_TABLE = {
+    L: [
+        [0, 0, 0, 0, 0], [7, 1, 19, 0, 0], [10, 1, 34, 0, 0], [15, 1, 55, 0, 0], [20, 1, 80, 0, 0], [26, 1, 108, 0, 0],
+        [18, 2, 68, 0, 0], [20, 2, 78, 0, 0], [24, 2, 97, 0, 0], [30, 2, 116, 0, 0], [18, 2, 68, 2, 69],
+        [20, 4, 81, 0, 0], [24, 2, 92, 2, 93], [26, 4, 107, 0, 0], [30, 3, 115, 1, 116], [22, 5, 87, 1, 88],
+        [24, 5, 98, 1, 99], [28, 1, 107, 5, 108], [30, 5, 120, 1, 121], [28, 3, 113, 4, 114], [28, 3, 107, 5, 108],
+        [28, 4, 116, 4, 117], [28, 2, 111, 7, 112], [30, 4, 121, 5, 122], [30, 6, 117, 4, 118], [26, 8, 106, 4, 107],
+        [28, 10, 114, 2, 115], [30, 8, 122, 4, 123], [30, 3, 117, 10, 118], [30, 7, 116, 7, 117], [30, 5, 115, 10, 116],
+        [30, 13, 115, 3, 116], [30, 17, 115, 0, 0], [30, 17, 115, 1, 116], [30, 13, 115, 6, 116], [30, 12, 121, 7, 122],
+        [30, 6, 121, 14, 122], [30, 17, 122, 4, 123], [30, 4, 122, 18, 123], [30, 20, 117, 4, 118], [30, 19, 118, 6, 119],
+    ],
+    M: [
+        [0, 0, 0, 0, 0], [10, 1, 16, 0, 0], [16, 1, 28, 0, 0], [26, 1, 44, 0, 0], [18, 2, 32, 0, 0], [24, 2, 43, 0, 0],
+        [16, 4, 27, 0, 0], [18, 4, 31, 0, 0], [22, 2, 38, 2, 39], [22, 3, 36, 2, 37], [26, 4, 43, 1, 44],
+        [30, 1, 50, 4, 51], [22, 6, 36, 2, 37], [22, 8, 37, 1, 38], [24, 4, 40, 5, 41], [24, 5, 41, 5, 42],
+        [28, 7, 45, 3, 46], [28, 10, 46, 1, 47], [26, 9, 43, 4, 44], [26, 3, 44, 11, 45], [26, 3, 41, 13, 42],
+        [26, 17, 42, 0, 0], [28, 17, 46, 0, 0], [28, 4, 47, 14, 48], [28, 6, 45, 14, 46], [28, 8, 47, 13, 48],
+        [28, 19, 46, 4, 47], [28, 22, 45, 3, 46], [28, 3, 45, 23, 46], [28, 21, 45, 7, 46], [28, 19, 47, 10, 48],
+        [28, 2, 46, 29, 47], [28, 10, 46, 23, 47], [28, 14, 46, 21, 47], [28, 14, 46, 23, 47], [28, 12, 47, 26, 48],
+        [28, 6, 47, 34, 48], [28, 29, 46, 14, 47], [28, 13, 46, 32, 47], [28, 40, 47, 7, 48], [28, 18, 47, 31, 48],
+    ],
+    Q: [
+        [0, 0, 0, 0, 0], [13, 1, 13, 0, 0], [22, 1, 22, 0, 0], [18, 2, 17, 0, 0], [26, 2, 24, 0, 0], [18, 2, 15, 2, 16],
+        [24, 4, 19, 0, 0], [18, 2, 14, 4, 15], [22, 4, 18, 2, 19], [20, 4, 16, 4, 17], [24, 6, 19, 2, 20],
+        [28, 4, 22, 4, 23], [26, 4, 20, 6, 21], [24, 8, 20, 4, 21], [20, 11, 16, 5, 17], [30, 5, 24, 7, 25],
+        [24, 15, 19, 2, 20], [28, 1, 22, 15, 23], [28, 17, 22, 1, 23], [26, 17, 21, 4, 22], [30, 15, 24, 5, 25],
+        [28, 17, 22, 6, 23], [30, 7, 24, 16, 25], [30, 11, 24, 14, 25], [30, 11, 24, 16, 25], [30, 7, 24, 22, 25],
+        [28, 28, 22, 6, 23], [30, 8, 23, 26, 24], [30, 4, 24, 31, 25], [30, 1, 23, 37, 24], [30, 15, 24, 25, 25],
+        [30, 42, 24, 1, 25], [30, 10, 24, 35, 25], [30, 29, 24, 19, 25], [30, 44, 24, 7, 25], [30, 39, 24, 14, 25],
+        [30, 46, 24, 10, 25], [30, 49, 24, 10, 25], [30, 48, 24, 14, 25], [30, 43, 24, 22, 25], [30, 34, 24, 34, 25],
+    ],
+    H: [
+        [0, 0, 0, 0, 0], [17, 1, 9, 0, 0], [28, 1, 16, 0, 0], [22, 2, 13, 0, 0], [16, 4, 9, 0, 0], [22, 2, 11, 2, 12],
+        [28, 4, 15, 0, 0], [26, 4, 13, 1, 14], [26, 4, 14, 2, 15], [24, 4, 12, 4, 13], [28, 6, 15, 2, 16],
+        [24, 3, 12, 8, 13], [28, 7, 14, 4, 15], [22, 12, 11, 4, 12], [24, 11, 12, 5, 13], [24, 11, 12, 7, 13],
+        [30, 3, 15, 13, 16], [28, 2, 14, 17, 15], [28, 2, 14, 19, 15], [26, 9, 13, 16, 14], [28, 15, 15, 10, 16],
+        [30, 19, 16, 6, 17], [24, 34, 13, 0, 0], [30, 16, 15, 14, 16], [30, 30, 16, 2, 17], [30, 22, 15, 13, 16],
+        [30, 33, 16, 4, 17], [30, 12, 15, 28, 16], [30, 11, 15, 31, 16], [30, 19, 15, 26, 16], [30, 23, 15, 25, 16],
+        [30, 23, 15, 28, 16], [30, 19, 15, 35, 16], [30, 11, 15, 46, 16], [30, 59, 16, 1, 17], [30, 22, 15, 41, 16],
+        [30, 2, 15, 64, 16], [30, 24, 15, 46, 16], [30, 42, 15, 32, 16], [30, 10, 15, 67, 16], [30, 20, 15, 61, 16],
+    ],
+};
+function ecRow(level, version) {
+    const row = EC_TABLE[level][version];
+    if (!row)
+        throw new Error('invalid version');
+    return row;
+}
+const ALIGN_POS = [
+    [], [], [6, 18], [6, 22], [6, 26], [6, 30], [6, 34], [6, 22, 38], [6, 24, 42], [6, 26, 46],
+    [6, 28, 50], [6, 30, 54], [6, 32, 58], [6, 34, 62], [6, 26, 46, 66], [6, 26, 48, 70], [6, 26, 50, 74],
+    [6, 30, 54, 78], [6, 30, 56, 82], [6, 30, 58, 86], [6, 34, 62, 90], [6, 28, 50, 72, 94], [6, 26, 50, 74, 98],
+    [6, 30, 54, 78, 102], [6, 28, 54, 80, 106], [6, 32, 58, 84, 110], [6, 30, 58, 86, 114], [6, 34, 62, 90, 118],
+    [6, 26, 50, 74, 98, 122], [6, 30, 54, 78, 102, 126], [6, 26, 52, 78, 104, 130], [6, 30, 56, 82, 108, 134],
+    [6, 34, 60, 86, 112, 138], [6, 30, 58, 86, 114, 142], [6, 34, 62, 90, 118, 146], [6, 30, 54, 78, 102, 126, 150],
+    [6, 24, 50, 76, 102, 128, 154], [6, 28, 54, 80, 106, 132, 158], [6, 32, 58, 84, 110, 136, 162],
+    [6, 26, 54, 82, 110, 138, 166], [6, 30, 58, 86, 114, 142, 170],
+];
+const EC_FORMAT_BITS = { L: 0b01, M: 0b00, Q: 0b11, H: 0b10 };
+function dataCodewords(version, level) {
+    const [, b1, d1, b2, d2] = ecRow(level, version);
+    return b1 * d1 + b2 * d2;
+}
+function chooseVersion(byteLen, level) {
+    for (let v = 1; v <= 40; v++) {
+        const cci = v < 10 ? 8 : 16;
+        const dataBits = 4 + cci + byteLen * 8;
+        if (dataCodewords(v, level) * 8 >= dataBits)
+            return v;
+    }
+    throw new Error('data too large for a QR code');
+}
+function buildBitstream(data, version, level) {
+    const cci = version < 10 ? 8 : 16;
+    const bits = [];
+    const push = (val, len) => {
+        for (let i = len - 1; i >= 0; i--)
+            bits.push((val >> i) & 1);
+    };
+    push(0b0100, 4);
+    push(data.length, cci);
+    for (const b of data)
+        push(b, 8);
+    const capacityBits = dataCodewords(version, level) * 8;
+    const term = Math.min(4, capacityBits - bits.length);
+    for (let i = 0; i < term; i++)
+        bits.push(0);
+    while (bits.length % 8 !== 0)
+        bits.push(0);
+    const pads = [0xec, 0x11];
+    let pi = 0;
+    while (bits.length < capacityBits) {
+        push(pads[pi % 2], 8);
+        pi++;
+    }
+    return bits;
+}
+function buildCodewords(bits, version, level) {
+    const [ecPerBlock, b1, d1, b2, d2] = ecRow(level, version);
+    const dataBytes = [];
+    for (let i = 0; i < bits.length; i += 8) {
+        let byte = 0;
+        for (let j = 0; j < 8; j++)
+            byte = (byte << 1) | bits[i + j];
+        dataBytes.push(byte);
+    }
+    const blocks = [];
+    let offset = 0;
+    const make = (count, dlen) => {
+        for (let i = 0; i < count; i++) {
+            const d = dataBytes.slice(offset, offset + dlen);
+            offset += dlen;
+            blocks.push({ data: d, ec: rsEncode(d, ecPerBlock) });
+        }
+    };
+    make(b1, d1);
+    if (b2)
+        make(b2, d2);
+    const result = [];
+    const maxData = Math.max(d1, d2);
+    for (let i = 0; i < maxData; i++) {
+        for (const blk of blocks) {
+            const v = blk.data[i];
+            if (v !== undefined)
+                result.push(v);
+        }
+    }
+    for (let i = 0; i < ecPerBlock; i++) {
+        for (const blk of blocks)
+            result.push(blk.ec[i]);
+    }
+    return result;
+}
+class Grid {
+    size;
+    cells;
+    constructor(size) {
+        this.size = size;
+        this.cells = new Int8Array(size * size).fill(-1);
+    }
+    get(r, c) {
+        return this.cells[r * this.size + c];
+    }
+    set(r, c, v) {
+        this.cells[r * this.size + c] = v;
+    }
+    isSet(r, c) {
+        return this.cells[r * this.size + c] !== -1;
+    }
+}
+function placeFinder(m, r, c) {
+    for (let dr = -1; dr <= 7; dr++) {
+        for (let dc = -1; dc <= 7; dc++) {
+            const rr = r + dr;
+            const cc = c + dc;
+            if (rr < 0 || cc < 0 || rr >= m.size || cc >= m.size)
+                continue;
+            const inRing = dr >= 0 && dr <= 6 && dc >= 0 && dc <= 6 && (dr === 0 || dr === 6 || dc === 0 || dc === 6);
+            const inCenter = dr >= 2 && dr <= 4 && dc >= 2 && dc <= 4;
+            m.set(rr, cc, inRing || inCenter ? 1 : 0);
+        }
+    }
+}
+function placeAlignment(m, version) {
+    const centers = ALIGN_POS[version] ?? [];
+    for (const r of centers) {
+        for (const c of centers) {
+            if ((r <= 8 && c <= 8) || (r <= 8 && c >= m.size - 9) || (r >= m.size - 9 && c <= 8))
+                continue;
+            for (let dr = -2; dr <= 2; dr++) {
+                for (let dc = -2; dc <= 2; dc++) {
+                    m.set(r + dr, c + dc, Math.max(Math.abs(dr), Math.abs(dc)) !== 1 ? 1 : 0);
+                }
+            }
+        }
+    }
+}
+function placeTiming(m) {
+    for (let i = 8; i < m.size - 8; i++) {
+        const v = i % 2 === 0 ? 1 : 0;
+        if (!m.isSet(6, i))
+            m.set(6, i, v);
+        if (!m.isSet(i, 6))
+            m.set(i, 6, v);
+    }
+}
+function reserveFormat(size, version) {
+    const reserved = new Uint8Array(size * size);
+    const mark = (r, c) => {
+        if (r >= 0 && c >= 0 && r < size && c < size)
+            reserved[r * size + c] = 1;
+    };
+    for (let i = 0; i <= 8; i++) {
+        mark(8, i);
+        mark(i, 8);
+    }
+    for (let i = 0; i <= 7; i++) {
+        mark(8, size - 1 - i);
+        mark(size - 1 - i, 8);
+    }
+    mark(size - 8, 8);
+    if (version >= 7) {
+        for (let i = 0; i < 6; i++) {
+            for (let j = 0; j < 3; j++) {
+                mark(i, size - 11 + j);
+                mark(size - 11 + j, i);
+            }
+        }
+    }
+    return reserved;
+}
+function functionMap(m, reserved) {
+    const size = m.size;
+    const out = new Uint8Array(size * size);
+    for (let r = 0; r < size; r++) {
+        for (let c = 0; c < size; c++) {
+            out[r * size + c] = m.isSet(r, c) || reserved[r * size + c] === 1 ? 1 : 0;
+        }
+    }
+    return out;
+}
+function placeData(m, funcMap, codewords) {
+    const size = m.size;
+    const bits = [];
+    for (const cw of codewords)
+        for (let i = 7; i >= 0; i--)
+            bits.push((cw >> i) & 1);
+    let bitIdx = 0;
+    let upward = true;
+    for (let col = size - 1; col > 0; col -= 2) {
+        if (col === 6)
+            col--;
+        for (let i = 0; i < size; i++) {
+            const row = upward ? size - 1 - i : i;
+            for (let dc = 0; dc < 2; dc++) {
+                const c = col - dc;
+                if (funcMap[row * size + c] === 1)
+                    continue;
+                m.set(row, c, bitIdx < bits.length ? bits[bitIdx] : 0);
+                bitIdx++;
+            }
+        }
+        upward = !upward;
+    }
+}
+const MASKS = [
+    (r, c) => (r + c) % 2 === 0,
+    (r) => r % 2 === 0,
+    (_r, c) => c % 3 === 0,
+    (r, c) => (r + c) % 3 === 0,
+    (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+    (r, c) => ((r * c) % 2) + ((r * c) % 3) === 0,
+    (r, c) => (((r * c) % 2) + ((r * c) % 3)) % 2 === 0,
+    (r, c) => (((r + c) % 2) + ((r * c) % 3)) % 2 === 0,
+];
+function maskFn(mask) {
+    return MASKS[mask] ?? MASKS[0] ?? (() => false);
+}
+function applyMask(m, funcMap, mask) {
+    const size = m.size;
+    const fn = maskFn(mask);
+    const out = new Uint8Array(size * size);
+    for (let r = 0; r < size; r++) {
+        for (let c = 0; c < size; c++) {
+            let v = m.get(r, c) === 1;
+            if (funcMap[r * size + c] !== 1 && fn(r, c))
+                v = !v;
+            out[r * size + c] = v ? 1 : 0;
+        }
+    }
+    return out;
+}
+function formatBits(level, mask) {
+    const data = (EC_FORMAT_BITS[level] << 3) | mask;
+    let rem = data << 10;
+    for (let i = 14; i >= 10; i--) {
+        if ((rem >> i) & 1)
+            rem ^= 0x537 << (i - 10);
+    }
+    return ((data << 10) | rem) ^ 0x5412;
+}
+function versionBits(version) {
+    let rem = version << 12;
+    for (let i = 17; i >= 12; i--) {
+        if ((rem >> i) & 1)
+            rem ^= 0x1f25 << (i - 12);
+    }
+    return (version << 12) | rem;
+}
+function placeFormatAndVersion(out, size, level, mask, version) {
+    const set = (r, c, v) => {
+        out[r * size + c] = v;
+    };
+    const fmt = formatBits(level, mask);
+    const getBit = (i) => (fmt >> (14 - i)) & 1;
+    for (let i = 0; i <= 5; i++)
+        set(8, i, getBit(i));
+    set(8, 7, getBit(6));
+    set(8, 8, getBit(7));
+    set(7, 8, getBit(8));
+    for (let i = 9; i <= 14; i++)
+        set(14 - i, 8, getBit(i));
+    for (let i = 0; i <= 7; i++)
+        set(size - 1 - i, 8, getBit(i));
+    for (let i = 8; i <= 14; i++)
+        set(8, size - 15 + i, getBit(i));
+    set(size - 8, 8, 1);
+    if (version >= 7) {
+        const vb = versionBits(version);
+        for (let i = 0; i < 18; i++) {
+            const bit = (vb >> i) & 1;
+            const r = Math.floor(i / 3);
+            const c = i % 3;
+            set(r, size - 11 + c, bit);
+            set(size - 11 + c, r, bit);
+        }
+    }
+}
+function penalty(m, n) {
+    const at = (r, c) => m[r * n + c];
+    let score = 0;
+    for (let line = 0; line < n; line++) {
+        for (let dir = 0; dir < 2; dir++) {
+            let run = 1;
+            let prev = dir === 0 ? at(line, 0) : at(0, line);
+            for (let i = 1; i < n; i++) {
+                const cur = dir === 0 ? at(line, i) : at(i, line);
+                if (cur === prev) {
+                    run++;
+                    if (run === 5)
+                        score += 3;
+                    else if (run > 5)
+                        score += 1;
+                }
+                else {
+                    run = 1;
+                    prev = cur;
+                }
+            }
+        }
+    }
+    for (let r = 0; r < n - 1; r++) {
+        for (let c = 0; c < n - 1; c++) {
+            const v = at(r, c);
+            if (v === at(r, c + 1) && v === at(r + 1, c) && v === at(r + 1, c + 1))
+                score += 3;
+        }
+    }
+    const pat1 = [1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0];
+    const pat2 = [0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1];
+    for (let r = 0; r < n; r++) {
+        for (let c = 0; c <= n - 11; c++) {
+            let ok1 = true;
+            let ok2 = true;
+            for (let k = 0; k < 11; k++) {
+                const v = at(r, c + k);
+                if (v !== pat1[k])
+                    ok1 = false;
+                if (v !== pat2[k])
+                    ok2 = false;
+            }
+            if (ok1 || ok2)
+                score += 40;
+        }
+    }
+    for (let c = 0; c < n; c++) {
+        for (let r = 0; r <= n - 11; r++) {
+            let ok1 = true;
+            let ok2 = true;
+            for (let k = 0; k < 11; k++) {
+                const v = at(r + k, c);
+                if (v !== pat1[k])
+                    ok1 = false;
+                if (v !== pat2[k])
+                    ok2 = false;
+            }
+            if (ok1 || ok2)
+                score += 40;
+        }
+    }
+    let dark = 0;
+    for (let i = 0; i < m.length; i++)
+        dark += m[i];
+    const ratio = (dark * 100) / (n * n);
+    score += Math.floor(Math.abs(ratio - 50) / 5) * 10;
+    return score;
+}
+export function encodeQr(text, level = 'M') {
+    const data = new TextEncoder().encode(text);
+    const version = chooseVersion(data.length, level);
+    const size = version * 4 + 17;
+    const bits = buildBitstream(data, version, level);
+    const codewords = buildCodewords(bits, version, level);
+    const base = new Grid(size);
+    placeFinder(base, 0, 0);
+    placeFinder(base, 0, size - 7);
+    placeFinder(base, size - 7, 0);
+    placeAlignment(base, version);
+    placeTiming(base);
+    const reserved = reserveFormat(size, version);
+    const funcMap = functionMap(base, reserved);
+    placeData(base, funcMap, codewords);
+    let best = null;
+    let bestScore = Infinity;
+    for (let mask = 0; mask < 8; mask++) {
+        const masked = applyMask(base, funcMap, mask);
+        placeFormatAndVersion(masked, size, level, mask, version);
+        const p = penalty(masked, size);
+        if (p < bestScore) {
+            bestScore = p;
+            best = masked;
+        }
+    }
+    const grid = best;
+    const out = [];
+    for (let r = 0; r < size; r++) {
+        const row = [];
+        for (let c = 0; c < size; c++)
+            row.push(grid[r * size + c] === 1);
+        out.push(row);
+    }
+    return out;
+}

package/dist/components/quantity-stepper.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from 'react';
+export interface QuantityStepperProps {
+    value: number;
+    onValueChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    /** A short trailing unit, shown inside the field so the number keeps its own column. */
+    unit?: ReactNode;
+    /** Labels the field itself; the two buttons derive theirs from decrementLabel/incrementLabel. */
+    label: string;
+    decrementLabel: string;
+    incrementLabel: string;
+    className?: string;
+}
+/**
+ * A number you nudge rather than type: the buttons carry the common case and the field
+ * stays editable for the uncommon one.
+ *
+ * The value is clamped on commit rather than on every keystroke, because clamping as
+ * someone types makes an intermediate "1" on the way to "12" jump to the minimum and eat
+ * the next digit. Typing is free; blur and the buttons are what settle it.
+ */
+export declare const QuantityStepper: import("react").ForwardRefExoticComponent<QuantityStepperProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/components/quantity-stepper.js

@@ -0,0 +1,43 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, useState } from 'react';
+import { Minus, Plus } from 'lucide-react';
+import { Button } from './button.js';
+import { Input } from './input.js';
+import { cn } from '../lib/cn.js';
+/**
+ * A number you nudge rather than type: the buttons carry the common case and the field
+ * stays editable for the uncommon one.
+ *
+ * The value is clamped on commit rather than on every keystroke, because clamping as
+ * someone types makes an intermediate "1" on the way to "12" jump to the minimum and eat
+ * the next digit. Typing is free; blur and the buttons are what settle it.
+ */
+export const QuantityStepper = forwardRef(function QuantityStepper({ value, onValueChange, min = 0, max = Number.MAX_SAFE_INTEGER, step = 1, disabled = false, unit, label, decrementLabel, incrementLabel, className, }, ref) {
+    const [draft, setDraft] = useState(String(value));
+    const [trackedValue, setTrackedValue] = useState(value);
+    // The committed value can move underneath an idle control — a peer's change, a rejected
+    // write rolling back — and the field has to follow it rather than show a stale number.
+    if (value !== trackedValue) {
+        setTrackedValue(value);
+        setDraft(String(value));
+    }
+    const clamp = (next) => Math.min(Math.max(next, min), max);
+    const commit = (next) => {
+        const settled = clamp(Number.isFinite(next) ? next : value);
+        setDraft(String(settled));
+        if (settled !== value)
+            onValueChange(settled);
+    };
+    return (_jsxs("div", { "data-slot": "quantity-stepper", className: cn('flex items-center gap-1.5', className), children: [_jsx(Button, { type: "button", variant: "outline", size: "icon-sm", "aria-label": decrementLabel, disabled: disabled || value <= min, onClick: () => commit(value - step), children: _jsx(Minus, { className: "size-3.5", strokeWidth: 1.5, "aria-hidden": true }) }), _jsxs("div", { className: "relative", children: [_jsx(Input, { ref: ref, value: draft, inputMode: "numeric", autoComplete: "off", disabled: disabled, "aria-label": label, className: cn('w-[92px] text-center font-mono text-[12.5px] tabular-nums', unit && 'pr-7'), onChange: (event) => setDraft(event.target.value.replace(/[^\d]/g, '')), onBlur: () => commit(Number.parseInt(draft, 10)), onKeyDown: (event) => {
+                            if (event.key === 'Enter') {
+                                event.preventDefault();
+                                event.currentTarget.blur();
+                            }
+                            else if (event.key === 'Escape') {
+                                event.preventDefault();
+                                setDraft(String(value));
+                                event.currentTarget.blur();
+                            }
+                        } }), unit ? (_jsx("span", { className: "text-muted-foreground pointer-events-none absolute inset-y-0 right-2.5 flex items-center font-mono text-[11px]", children: unit })) : null] }), _jsx(Button, { type: "button", variant: "outline", size: "icon-sm", "aria-label": incrementLabel, disabled: disabled || value >= max, onClick: () => commit(value + step), children: _jsx(Plus, { className: "size-3.5", strokeWidth: 1.5, "aria-hidden": true }) })] }));
+});

package/dist/components/radio-group.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import { RadioGroup as RadioGroupPrimitive } from "radix-ui";
+declare function RadioGroup({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Root>): React.JSX.Element;
+declare function RadioGroupItem({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Item>): React.JSX.Element;
+export { RadioGroup, RadioGroupItem };

package/dist/components/radio-group.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { RadioGroup as RadioGroupPrimitive } from "radix-ui";
+import { CircleIcon } from "lucide-react";
+import { cn } from "../lib/cn.js";
+function RadioGroup({ className, ...props }) {
+    return (_jsx(RadioGroupPrimitive.Root, { "data-slot": "radio-group", className: cn("grid gap-2", className), ...props }));
+}
+function RadioGroupItem({ className, ...props }) {
+    return (_jsx(RadioGroupPrimitive.Item, { "data-slot": "radio-group-item", className: cn("aspect-square size-4 shrink-0 rounded-full border border-input text-primary shadow-xs outline-none transition-[color,box-shadow] focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-checked:border-primary dark:bg-input/30", className), ...props, children: _jsx(RadioGroupPrimitive.Indicator, { "data-slot": "radio-group-indicator", className: "relative flex items-center justify-center", children: _jsx(CircleIcon, { className: "size-2 fill-primary text-primary" }) }) }));
+}
+export { RadioGroup, RadioGroupItem };

package/dist/components/rename-dialog.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+export interface RenameDialogProps {
+    open: boolean;
+    value: string;
+    title: string;
+    label: string;
+    confirmLabel: string;
+    cancelLabel: string;
+    onOpenChange: (open: boolean) => void;
+    onSubmit: (next: string) => Promise<void> | void;
+    description?: string;
+    placeholder?: string;
+    busy?: boolean;
+    error?: string | null;
+    requiredError?: string;
+    detail?: ReactNode;
+    detailPlacement?: 'top' | 'bottom';
+}
+export declare function RenameDialog({ open, value, title, label, confirmLabel, cancelLabel, onOpenChange, onSubmit, description, placeholder, busy, error, requiredError, detail, detailPlacement, }: RenameDialogProps): import("react").JSX.Element;