samey-cli 0.0.0-stage → 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,316 @@
+export type Severity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+export type Category = 'visual' | 'content' | 'functional' | 'accessibility' | 'technical';
+export type FindingSource = 'rendered' | 'static' | 'model';
+export type ViewportName = 'desktop' | 'mobile';
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Evidence {
+    /** `dom` is an element on a rendered page; `network` and `console` extend the base set. */
+    type: 'screenshot' | 'dom' | 'source' | 'metric' | 'text' | 'network' | 'console';
+    route?: string;
+    /** Other routes where the identical evidence was seen (a shared component). */
+    alsoOn?: string[];
+    viewport?: ViewportName;
+    selector?: string;
+    rect?: Rect;
+    /** Relative to the project root, posix separators, validated to stay inside it. */
+    file?: string;
+    line?: number;
+    excerpt?: string;
+    /** Relative to the report directory. */
+    screenshotPath?: string;
+    metric?: Record<string, number | string>;
+    detail?: string;
+}
+export interface Finding {
+    /** Stable for the same rule and evidence: `${ruleId}-${fingerprint prefix}`. */
+    id: string;
+    ruleId: string;
+    ruleVersion: number;
+    category: Category;
+    title: string;
+    description: string;
+    severity: Severity;
+    /** 0 to 1. How sure the rule is that the observation is real, separate from how much it matters. */
+    confidence: number;
+    evidence: Evidence[];
+    recommendation: string;
+    /** Hash of rule id and evidence identity (not routes), used for deduplication. */
+    fingerprint: string;
+    /** True for measured defects; false for design observations that need judgment. */
+    verified: boolean;
+    source: FindingSource;
+    routes?: string[];
+    /** Model findings are advisory candidates and never affect the score. */
+    advisory?: boolean;
+}
+export interface ElementRef {
+    selector: string;
+    rect: Rect;
+}
+export interface GradientFact extends ElementRef {
+    value: string;
+    area: number;
+    isText: boolean;
+}
+export interface GlowFact extends ElementRef {
+    value: string;
+    kind: 'shadow' | 'blur-blob' | 'backdrop';
+}
+export interface SectionFact extends ElementRef {
+    index: number;
+    tag: string;
+    /** Coarse layout fingerprint used for sameness comparisons. */
+    signature: string;
+    heading?: string;
+    text: string;
+    centered: boolean;
+    columns: number;
+    cardCount: number;
+    cardSignature?: string;
+    buttonCount: number;
+    imageCount: number;
+    hasBlockquote: boolean;
+    hasDetails: boolean;
+    hasPrice: boolean;
+    isChrome: boolean;
+}
+export interface HeadingFact extends ElementRef {
+    level: number;
+    text: string;
+}
+export interface ControlFact extends ElementRef {
+    tag: string;
+    text: string;
+    name: string;
+    href?: string;
+    type?: string;
+    inForm: boolean;
+}
+export interface LinkFact extends ElementRef {
+    href: string;
+    text: string;
+    internal: boolean;
+}
+export interface ImageFact extends ElementRef {
+    src: string;
+    alt: string | null;
+    broken: boolean;
+    decorative: boolean;
+}
+export interface TextBlock extends ElementRef {
+    tag: string;
+    text: string;
+}
+export interface StyleCounts {
+    colors: Record<string, number>;
+    backgrounds: Record<string, number>;
+    fontSizes: Record<string, number>;
+    fontFamilies: Record<string, number>;
+    radii: Record<string, number>;
+    shadows: Record<string, number>;
+    spacing: Record<string, number>;
+}
+export interface ViewportFacts {
+    viewport: ViewportName;
+    width: number;
+    height: number;
+    docHeight: number;
+    scrollWidth: number;
+    screenshot?: string;
+    screenshotHeight?: number;
+    lang: string | null;
+    title: string;
+    metaDescription: string | null;
+    sections: SectionFact[];
+    headings: HeadingFact[];
+    controls: ControlFact[];
+    links: LinkFact[];
+    images: ImageFact[];
+    textBlocks: TextBlock[];
+    gradients: GradientFact[];
+    glows: GlowFact[];
+    styles: StyleCounts;
+    smallTargets: (ElementRef & {
+        text: string;
+        w: number;
+        h: number;
+    })[];
+    tinyText: (ElementRef & {
+        text: string;
+        size: number;
+    })[];
+    overflowing: (ElementRef & {
+        right: number;
+    })[];
+    unlabeledInputs: (ElementRef & {
+        type: string;
+    })[];
+    wordCount: number;
+}
+export interface InteractionResult extends ElementRef {
+    text: string;
+    outcome: 'navigated' | 'changed' | 'no-effect' | 'error' | 'skipped';
+    detail?: string;
+}
+export interface PageFacts {
+    url: string;
+    path: string;
+    status: number | null;
+    loadMs: number;
+    error?: string;
+    consoleErrors: string[];
+    failedRequests: {
+        url: string;
+        status?: number;
+        failure?: string;
+        resourceType: string;
+    }[];
+    desktop?: ViewportFacts;
+    mobile?: ViewportFacts;
+    interactions: InteractionResult[];
+}
+export interface CrawlResult {
+    baseUrl: string;
+    pages: PageFacts[];
+    skipped: {
+        url: string;
+        reason: string;
+    }[];
+    brokenLinks: {
+        from: string;
+        url: string;
+        status: number | null;
+        error?: string;
+    }[];
+    discovered: number;
+    limitHit: boolean;
+    network: {
+        blocked: {
+            url: string;
+            reason: string;
+        }[];
+        requests: number;
+        bytes: number;
+        budgetExceeded: boolean;
+        navRedirects?: Map<string, string>;
+    };
+}
+export interface SourceFile {
+    path: string;
+    ext: string;
+    content: string;
+}
+export interface RepoFacts {
+    root: string;
+    name?: string;
+    frameworks: string[];
+    packageManager?: string;
+    scripts: Record<string, string>;
+    files: SourceFile[];
+    fileCount: number;
+    truncated: boolean;
+    routeHints: string[];
+    staticRoot?: string;
+}
+export interface CategoryScore {
+    category: Category;
+    /** 0 = no slop indicators found, 100 = many or severe. null = not measured. */
+    score: number | null;
+    weight: number;
+    /** Sum of weighted penalties before saturation. */
+    penalty: number;
+    deductions: {
+        findingId: string;
+        ruleId: string;
+        penalty: number;
+    }[];
+}
+export interface Coverage {
+    staticAnalysis: boolean;
+    rendered: boolean;
+    /** A rendered target existed and the browser ran, whether or not any page loaded. */
+    renderAttempted: boolean;
+    renderedNote?: string;
+    pagesAudited: number;
+    pagesFailed: number;
+    routeLimitHit: boolean;
+    skipped: {
+        url: string;
+        reason: string;
+    }[];
+    interactions: boolean;
+    /** Requests the network policy refused (sample), e.g. a page referencing a private address. */
+    blockedRequests: {
+        url: string;
+        reason: string;
+    }[];
+    networkBudgetExceeded: boolean;
+    model: {
+        enabled: boolean;
+        name?: string;
+        note?: string;
+    };
+    /** Plain-language list of everything that limits how complete this scan is. */
+    limitations: string[];
+}
+export interface AuditReport {
+    schemaVersion: 1;
+    scanId: string;
+    tool: {
+        name: 'samey';
+        version: string;
+    };
+    generatedAt: string;
+    durationMs: number;
+    /** A short hash of the project path or URL origin, safe to share. */
+    project: {
+        id: string;
+        name?: string;
+    };
+    target: {
+        path?: string;
+        url?: string;
+    };
+    /** Overall slop score: 0 = few indicators, 100 = many or severe. null when nothing was measured. */
+    score: number | null;
+    categories: CategoryScore[];
+    findings: Finding[];
+    coverage: Coverage;
+    versions: {
+        scoring: string;
+        rules: Record<string, number>;
+        model?: string;
+    };
+    viewports: {
+        name: ViewportName;
+        width: number;
+        height: number;
+    }[];
+    failedRoutes: {
+        url: string;
+        reason: string;
+    }[];
+    repo?: {
+        name?: string;
+        frameworks: string[];
+        fileCount: number;
+        truncated: boolean;
+    };
+    pages: {
+        url: string;
+        path: string;
+        status: number | null;
+        error?: string;
+        title?: string;
+        screenshots: Partial<Record<ViewportName, {
+            file: string;
+            width: number;
+            height: number;
+        }>>;
+    }[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/util/color.d.ts

@@ -0,0 +1,25 @@
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface HSL {
+    h: number;
+    s: number;
+    l: number;
+}
+/** Parses a single CSS color value. Returns null for keywords it does not know. */
+export declare function parseColor(input: string): RGB | null;
+export declare function rgbToHsl({ r, g, b }: RGB): HSL;
+/** Pulls every color literal out of a CSS value such as a gradient or shadow. */
+export declare function extractColors(value: string): RGB[];
+export type HueFamily = 'neutral' | 'red' | 'orange' | 'yellow' | 'green' | 'teal' | 'cyan' | 'blue' | 'indigo' | 'violet' | 'fuchsia' | 'pink';
+export declare function hueFamily(c: RGB): HueFamily;
+/**
+ * The stock "AI landing page" gradient: two or more saturated stops drawn from the
+ * blue-indigo-violet-pink band, with at least one stop in indigo/violet/fuchsia.
+ */
+export declare function isStockGradient(value: string): boolean;
+export declare function isSaturated(c: RGB): boolean;
+export declare function toHex(c: RGB): string;

package/dist/util/color.js

@@ -0,0 +1,180 @@
+const clamp255 = (n) => Math.max(0, Math.min(255, Math.round(n)));
+function num(token, scale = 1) {
+    const t = token.trim();
+    if (t === 'none')
+        return 0;
+    if (t.endsWith('%'))
+        return (parseFloat(t) / 100) * scale;
+    return parseFloat(t);
+}
+function splitArgs(inner) {
+    const [main, alpha] = inner.split('/');
+    const parts = main.replace(/,/g, ' ').trim().split(/\s+/).filter(Boolean);
+    return { parts, alpha: alpha?.trim() };
+}
+function linearToSrgb(c) {
+    const v = c <= 0.0031308 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+    return v * 255;
+}
+function oklabToRgb(L, a, b, alpha) {
+    const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+    const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+    const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+    const l = l_ ** 3;
+    const m = m_ ** 3;
+    const s = s_ ** 3;
+    return {
+        r: clamp255(linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s)),
+        g: clamp255(linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s)),
+        b: clamp255(linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)),
+        a: alpha,
+    };
+}
+function hslToRgb(h, s, l, a) {
+    const k = (n) => (n + h / 30) % 12;
+    const f = (n) => l - s * Math.min(l, 1 - l) * Math.max(-1, Math.min(k(n) - 3, 9 - k(n), 1));
+    return { r: clamp255(f(0) * 255), g: clamp255(f(8) * 255), b: clamp255(f(4) * 255), a };
+}
+/** Parses a single CSS color value. Returns null for keywords it does not know. */
+export function parseColor(input) {
+    const s = input.trim().toLowerCase();
+    if (s === 'transparent')
+        return { r: 0, g: 0, b: 0, a: 0 };
+    if (s === 'white')
+        return { r: 255, g: 255, b: 255, a: 1 };
+    if (s === 'black')
+        return { r: 0, g: 0, b: 0, a: 1 };
+    const hex = s.match(/^#([0-9a-f]{3,8})$/);
+    if (hex) {
+        let h = hex[1];
+        if (h.length === 3 || h.length === 4)
+            h = [...h].map((c) => c + c).join('');
+        if (h.length !== 6 && h.length !== 8)
+            return null;
+        return {
+            r: parseInt(h.slice(0, 2), 16),
+            g: parseInt(h.slice(2, 4), 16),
+            b: parseInt(h.slice(4, 6), 16),
+            a: h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : 1,
+        };
+    }
+    const fn = s.match(/^([a-z]+)\((.*)\)$/);
+    if (!fn)
+        return null;
+    const [, name, inner] = fn;
+    const { parts, alpha } = splitArgs(inner);
+    const a = alpha !== undefined ? num(alpha, 1) : parts.length === 4 ? num(parts[3], 1) : 1;
+    switch (name) {
+        case 'rgb':
+        case 'rgba':
+            if (parts.length < 3)
+                return null;
+            return { r: clamp255(num(parts[0], 255)), g: clamp255(num(parts[1], 255)), b: clamp255(num(parts[2], 255)), a };
+        case 'hsl':
+        case 'hsla':
+            if (parts.length < 3)
+                return null;
+            return hslToRgb(parseFloat(parts[0]), num(parts[1], 1) / (parts[1].endsWith('%') ? 1 : 100), num(parts[2], 1) / (parts[2].endsWith('%') ? 1 : 100), a);
+        case 'oklch': {
+            if (parts.length < 3)
+                return null;
+            const L = num(parts[0], 1);
+            const C = num(parts[1], 0.4);
+            const H = (parseFloat(parts[2]) || 0) * (Math.PI / 180);
+            return oklabToRgb(L, C * Math.cos(H), C * Math.sin(H), a);
+        }
+        case 'oklab':
+            if (parts.length < 3)
+                return null;
+            return oklabToRgb(num(parts[0], 1), num(parts[1], 0.4), num(parts[2], 0.4), a);
+        case 'color': {
+            if (parts[0] !== 'srgb' || parts.length < 4)
+                return null;
+            return { r: clamp255(num(parts[1], 1) * 255), g: clamp255(num(parts[2], 1) * 255), b: clamp255(num(parts[3], 1) * 255), a };
+        }
+        default:
+            return null;
+    }
+}
+export function rgbToHsl({ r, g, b }) {
+    const rn = r / 255;
+    const gn = g / 255;
+    const bn = b / 255;
+    const max = Math.max(rn, gn, bn);
+    const min = Math.min(rn, gn, bn);
+    const l = (max + min) / 2;
+    if (max === min)
+        return { h: 0, s: 0, l };
+    const d = max - min;
+    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    let h;
+    if (max === rn)
+        h = (gn - bn) / d + (gn < bn ? 6 : 0);
+    else if (max === gn)
+        h = (bn - rn) / d + 2;
+    else
+        h = (rn - gn) / d + 4;
+    return { h: h * 60, s, l };
+}
+/** Pulls every color literal out of a CSS value such as a gradient or shadow. */
+export function extractColors(value) {
+    const re = /#[0-9a-f]{3,8}\b|(?:rgba?|hsla?|oklch|oklab|color)\([^()]*\)/gi;
+    const out = [];
+    for (const m of value.match(re) ?? []) {
+        const c = parseColor(m);
+        if (c)
+            out.push(c);
+    }
+    return out;
+}
+export function hueFamily(c) {
+    const { h, s, l } = rgbToHsl(c);
+    if (s < 0.25 || l < 0.08 || l > 0.96)
+        return 'neutral';
+    if (h < 15 || h >= 345)
+        return 'red';
+    if (h < 40)
+        return 'orange';
+    if (h < 65)
+        return 'yellow';
+    if (h < 150)
+        return 'green';
+    if (h < 175)
+        return 'teal';
+    if (h < 200)
+        return 'cyan';
+    if (h < 230)
+        return 'blue';
+    if (h < 255)
+        return 'indigo';
+    if (h < 285)
+        return 'violet';
+    if (h < 320)
+        return 'fuchsia';
+    return 'pink';
+}
+const COOL_SYNTH = new Set(['blue', 'indigo', 'violet', 'fuchsia', 'pink', 'cyan']);
+const CORE_SYNTH = new Set(['indigo', 'violet', 'fuchsia']);
+/**
+ * The stock "AI landing page" gradient: two or more saturated stops drawn from the
+ * blue-indigo-violet-pink band, with at least one stop in indigo/violet/fuchsia.
+ */
+export function isStockGradient(value) {
+    const stops = extractColors(value).filter((c) => c.a > 0.15);
+    const families = stops.map(hueFamily).filter((f) => f !== 'neutral');
+    if (families.length < 2)
+        return false;
+    if (!families.every((f) => COOL_SYNTH.has(f)))
+        return false;
+    if (!families.some((f) => CORE_SYNTH.has(f)))
+        return false;
+    // A tonal ramp within one family (indigo-500 to indigo-700) is a deliberate choice, not the stock look.
+    return new Set(families).size >= 2;
+}
+export function isSaturated(c) {
+    const { s, l } = rgbToHsl(c);
+    return s >= 0.4 && l > 0.15 && l < 0.9;
+}
+export function toHex(c) {
+    return '#' + [c.r, c.g, c.b].map((n) => n.toString(16).padStart(2, '0')).join('');
+}

package/dist/util/text.d.ts

@@ -0,0 +1,22 @@
+export interface PhraseMatch {
+    phrase: string;
+    index: number;
+}
+/**
+ * Stock marketing phrases that carry no product-specific information. Each entry is a
+ * label plus a pattern so reports can name the phrase family rather than the regex.
+ */
+export declare const STOCK_PHRASES: [string, RegExp][];
+export declare function findStockPhrases(text: string): PhraseMatch[];
+export declare const PLACEHOLDER_PATTERNS: [string, RegExp][];
+export declare function findPlaceholders(text: string): PhraseMatch[];
+export declare const CLAIM_PATTERNS: [string, RegExp][];
+export declare function findClaims(text: string): PhraseMatch[];
+/** Testimonial attribution like "Sarah Chen, CEO at Nimbus". */
+export declare const ATTRIBUTION: RegExp;
+export declare function hasEmoji(text: string): boolean;
+export declare function firstEmoji(text: string): string | undefined;
+export declare const GENERIC_LINK_TEXT: RegExp;
+export declare function normalizeText(text: string): string;
+export declare function truncate(text: string, max?: number): string;
+export declare function snippetAround(text: string, index: number, radius?: number): string;

package/dist/util/text.js

@@ -0,0 +1,106 @@
+/**
+ * Stock marketing phrases that carry no product-specific information. Each entry is a
+ * label plus a pattern so reports can name the phrase family rather than the regex.
+ */
+export const STOCK_PHRASES = [
+    ['unlock the power/potential', /\bunlock(?:ing)? (?:the |your )?(?:full )?(?:power|potential)\b/i],
+    ['supercharge', /\bsupercharg(?:e|es|ed|ing)\b/i],
+    ['revolutionize', /\brevolutioni[sz](?:e|es|ing)\b/i],
+    ['seamless', /\bseamless(?:ly)?\b/i],
+    ['elevate your', /\belevate (?:your|the)\b/i],
+    ['empower', /\bempower(?:s|ing)?\b/i],
+    ['next-generation', /\bnext[- ]gen(?:eration)?\b/i],
+    ['cutting-edge', /\bcutting[- ]edge\b/i],
+    ['game-changing', /\bgame[- ]chang(?:er|ing)\b/i],
+    ['all-in-one', /\ball[- ]in[- ]one\b/i],
+    ['effortless', /\beffortless(?:ly)?\b/i],
+    ['transform your', /\btransform (?:your|the way)\b/i],
+    ['to the next level', /\bto the next level\b/i],
+    ['built for the future', /\bbuilt for (?:the )?(?:future|modern)\b/i],
+    ['harness the power', /\bharness(?:ing)? the power\b/i],
+    ['streamline', /\bstreamlin(?:e|es|ed|ing)\b/i],
+    ['world-class', /\bworld[- ]class\b/i],
+    ['state-of-the-art', /\bstate[- ]of[- ]the[- ]art\b/i],
+    ['lightning/blazing fast', /\b(?:lightning|blazing(?:ly)?)[- ]fast\b/i],
+    ["in today's fast-paced world", /\bin today'?s (?:fast[- ]paced|digital|ever[- ]changing)\b/i],
+    ["whether you're a", /\bwhether you'?re an? \w+/i],
+    ['say goodbye to', /\bsay goodbye to\b/i],
+    ['look no further', /\blook no further\b/i],
+    ['boost your productivity', /\bboost (?:your )?productivity\b/i],
+    ['unleash', /\bunleash(?:es|ing)?\b/i],
+    ['reimagine', /\breimagin(?:e|ed|ing)\b/i],
+    ['at your fingertips', /\bat your fingertips\b/i],
+    ['ever-evolving', /\bever[- ]evolving\b/i],
+    ['leverage', /\bleverag(?:e|es|ing)\b/i],
+    ['innovative solutions', /\binnovative solutions?\b/i],
+    ['the future of', /\bthe future of \w+/i],
+    ['like never before', /\blike never before\b/i],
+    ['made simple', /\bmade (?:simple|easy)\b/i],
+    ['delve', /\bdelv(?:e|es|ing)\b/i],
+    ['tapestry', /\btapestry\b/i],
+];
+export function findStockPhrases(text) {
+    const out = [];
+    for (const [label, re] of STOCK_PHRASES) {
+        const m = re.exec(text);
+        if (m)
+            out.push({ phrase: label, index: m.index });
+    }
+    return out;
+}
+export const PLACEHOLDER_PATTERNS = [
+    ['lorem ipsum', /\blorem ipsum\b|\bdolor sit amet\b/i],
+    ['placeholder name', /\b(?:john|jane) (?:doe|smith)\b/i],
+    ['placeholder company', /\b(?:acme(?: corp(?:oration)?| inc)?|your company|company name|your brand|brand name)\b/i],
+    ['example domain', /\b[\w.-]*@?example\.(?:com|org|net)\b/i],
+    ['placeholder text', /\[(?:insert|your|add|placeholder)[^\]]*\]|\{\{\s*\w+\s*\}\}|\bplaceholder text\b/i],
+    ['TODO marker', /\b(?:TODO|FIXME|TBD)\b/],
+    ['dummy contact', /\b(?:123[- ]456[- ]7890|\(555\) ?\d{3}-\d{4}|555-\d{4}|123 (?:main|fake) st(?:reet)?)\b/i],
+];
+export function findPlaceholders(text) {
+    const out = [];
+    for (const [label, re] of PLACEHOLDER_PATTERNS) {
+        const m = re.exec(text);
+        if (m)
+            out.push({ phrase: label, index: m.index });
+    }
+    return out;
+}
+export const CLAIM_PATTERNS = [
+    ['trusted by N', /\btrusted by (?:over |more than )?[\d,.]+\s*[kKmM]?\+?/],
+    ['N+ users/customers', /\b[\d,.]+\s*[kKmM]?\+\s*(?:happy |satisfied |active )?(?:users|customers|developers|teams|companies|businesses|clients|creators)\b/i],
+    ['percentage claim', /\b\d{2,3}(?:\.\d+)?%\s*(?:uptime|satisfaction|faster|more|increase|growth|accuracy|reduction|of (?:users|customers))\b/i],
+    ['star rating', /★★★★★|\b(?:4\.\d|5(?:\.0)?)\s*\/\s*5\b|\b5[- ]star\b/i],
+    ['N x faster', /\b\d+x (?:faster|more|better|quicker)\b/i],
+];
+export function findClaims(text) {
+    const out = [];
+    for (const [label, re] of CLAIM_PATTERNS) {
+        const m = re.exec(text);
+        if (m)
+            out.push({ phrase: label, index: m.index });
+    }
+    return out;
+}
+/** Testimonial attribution like "Sarah Chen, CEO at Nimbus". */
+export const ATTRIBUTION = /\b[A-Z][a-z]+ [A-Z][a-z]+\s*[,\-–—|]\s*(?:CEO|CTO|COO|CFO|Founder|Co-founder|Head of|VP|Director|Lead|Manager|Product Manager|Engineer|Designer)\b/;
+const EMOJI = /\p{Extended_Pictographic}/u;
+export function hasEmoji(text) {
+    return EMOJI.test(text);
+}
+export function firstEmoji(text) {
+    return text.match(/\p{Extended_Pictographic}️?/u)?.[0];
+}
+export const GENERIC_LINK_TEXT = /^(?:learn more|read more|click here|more|here|details|see more|find out more)$/i;
+export function normalizeText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+export function truncate(text, max = 120) {
+    const t = normalizeText(text);
+    return t.length > max ? t.slice(0, max - 1) + '…' : t;
+}
+export function snippetAround(text, index, radius = 60) {
+    const start = Math.max(0, index - radius);
+    const end = Math.min(text.length, index + radius);
+    return (start > 0 ? '…' : '') + normalizeText(text.slice(start, end)) + (end < text.length ? '…' : '');
+}