waybetter 0.1.1 → 0.7.0

package/cli/strings.mjs

@@ -0,0 +1,123 @@
+// `waybetter strings check`: a string pack against a site's string inventory, with the
+// framework's rules (waybetter/runtime/stringPacks: the envelope, only inventory keys, parameter
+// names, plural and select kinds, no markup) and its coverage.
+//
+//   waybetter strings check pack.strings.json --inventory strings/x.web.inventory.json
+//   waybetter strings check pack.strings.json            the inventory comes from the config
+//   waybetter strings check pack.strings.json --verbose  list every key that was refused or unknown
+//
+// Config: waybetter.strings.json in the app's root (or --config <file>); paths are relative to it.
+//
+//   { "inventories": ["strings/x.web.inventory.json"] }
+//
+// The pack names its site and catalog; the inventory with the same two is used. Exit 1 when the
+// envelope is invalid, a value is refused or a key is unknown (none of those is ever applied).
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+export const STRINGS_CONFIG_FILE = 'waybetter.strings.json';
+
+export const STRINGS_USAGE = `Usage:
+  waybetter strings check <pack> [--inventory <file>] [--verbose] [--config <file>]
+      Validates a string pack against the site's string inventory and prints its coverage.
+
+Config: ${STRINGS_CONFIG_FILE} in the app's root (inventories).`;
+
+class StringsError extends Error {}
+
+const LISTED = 12;
+
+/** The pack rules: the framework's sources inside its repository, else the built package. */
+async function loadRules() {
+  const source = fileURLToPath(new URL('../../runtime/src/stringPacks.ts', import.meta.url));
+  const built = fileURLToPath(new URL('../dist/runtime/stringPacks.js', import.meta.url));
+  const file = existsSync(source) ? source : built;
+  if (!existsSync(file)) throw new StringsError('the string pack rules are not built (run the package build)');
+  return import(pathToFileURL(file).href);
+}
+
+function readJson(file, what) {
+  if (!existsSync(file)) throw new StringsError(`${what} not found: ${file}`);
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch (error) {
+    throw new StringsError(`${what} is not JSON: ${file} (${error instanceof Error ? error.message : error})`);
+  }
+}
+
+/** The inventories a config lists, as absolute paths. */
+export function loadStringsConfig(cwd, file) {
+  const path = resolve(cwd, file ?? STRINGS_CONFIG_FILE);
+  if (!existsSync(path)) throw new StringsError(`${relative(cwd, path) || path} not found: pass --inventory <file> (see \`waybetter strings --help\`)`);
+  const config = readJson(path, 'the config');
+  if (!Array.isArray(config.inventories) || config.inventories.some(item => typeof item !== 'string')) throw new StringsError(`${relative(cwd, path)}: "inventories" must be a list of files`);
+  return { inventories: config.inventories.map(item => resolve(dirname(path), item)) };
+}
+
+const percent = (part, whole) => (whole ? `${(part / whole * 100).toFixed(part && part < whole / 1000 ? 2 : 1)}%` : 'n/a');
+
+/**
+ * Checks one pack. `inventories` are inventory files; the one for the pack's site and catalog is
+ * used. Returns the lines to print, the number of errors and the compiled report.
+ */
+export async function checkPack(packFile, inventories, { verbose = false } = {}) {
+  const rules = await loadRules();
+  const pack = readJson(packFile, 'the pack');
+  const lines = [];
+  const issues = rules.checkPackShape(pack);
+  for (const issue of issues) lines.push(`${issue.level}: ${issue.message}`);
+  if (issues.some(issue => issue.level === 'error')) return { lines, errors: issues.filter(issue => issue.level === 'error').length, report: null, coverage: null };
+  const loaded = inventories.map(file => ({ file, inventory: readJson(file, 'the inventory') }));
+  const match = loaded.find(item => item.inventory.site === pack.site && item.inventory.catalog === pack.catalog);
+  if (!match) throw new StringsError(`no inventory for ${pack.site}/${pack.catalog} (have: ${loaded.map(item => `${item.inventory.site}/${item.inventory.catalog}`).join(', ') || 'none'})`);
+  if (match.inventory.format !== 1 || typeof match.inventory.entries !== 'object') throw new StringsError(`${match.file} is not a string inventory`);
+  const compiled = rules.compilePack(pack, match.inventory);
+  const { report } = compiled;
+  const coverage = rules.coverage(match.inventory, compiled);
+  lines.push(`${pack.name} (${pack.language}) for ${pack.site}/${pack.catalog}, inventory build ${match.inventory.build ?? 'unknown'}`);
+  lines.push(`${report.total} strings: ${report.valid} valid, ${report.rejected.length} refused, ${report.unknown.length} unknown`);
+  if (pack.when?.languages) lines.push(`Applies only while the site shows: ${pack.when.languages.join(', ')}`);
+  if (pack.rewrite) lines.push(`Rewords ${Object.keys(pack.rewrite.words).length} words inside the site's own text: ${Object.keys(pack.rewrite.words).slice(0, 6).join(', ')}${Object.keys(pack.rewrite.words).length > 6 ? ', …' : ''}`);
+  const list = (items, render) => {
+    for (const item of verbose ? items : items.slice(0, LISTED)) lines.push(`  ${render(item)}`);
+    if (!verbose && items.length > LISTED) lines.push(`  … ${items.length - LISTED} more (--verbose lists all)`);
+  };
+  if (report.rejected.length) {
+    lines.push('Refused (not applied, the site\'s text stays):');
+    list(report.rejected, item => `${item.id}: ${item.reason}`);
+  }
+  if (report.unknown.length) {
+    lines.push('Unknown keys (not in the inventory, never applied):');
+    list(report.unknown, id => id);
+  }
+  lines.push('Coverage:');
+  for (const [group, numbers] of Object.entries(coverage)) {
+    lines.push(`  ${group.padEnd(8)} ${numbers.translated} of ${numbers.translatable} translatable strings (${percent(numbers.translated, numbers.translatable)})${numbers.closed ? `; ${numbers.closed} not translatable yet (rich text, formatters)` : ''}`);
+  }
+  return { lines, errors: report.rejected.length + report.unknown.length, report, coverage };
+}
+
+export async function stringsCommand(args, { cwd = process.cwd(), log = console.log } = {}) {
+  const [action, ...rest] = args;
+  const value = flag => {
+    const at = rest.indexOf(flag);
+    if (at < 0) return undefined;
+    if (!rest[at + 1] || rest[at + 1].startsWith('--')) throw new StringsError(`${flag} needs a file`);
+    return rest[at + 1];
+  };
+  if (action === 'check') {
+    const inventory = value('--inventory');
+    const config = value('--config');
+    const taken = new Set([inventory, config].filter(Boolean));
+    const [pack, ...extra] = rest.filter(arg => !arg.startsWith('--') && !taken.has(arg));
+    if (!pack || extra.length) throw new StringsError('check needs one pack file');
+    const at = file => (isAbsolute(file) ? file : resolve(cwd, file));
+    const inventories = inventory ? [at(inventory)] : loadStringsConfig(cwd, config).inventories;
+    const result = await checkPack(at(pack), inventories, { verbose: rest.includes('--verbose') });
+    for (const line of result.lines) log(line);
+    return result.errors ? 1 : 0;
+  }
+  log(STRINGS_USAGE);
+  return action && action !== '--help' && action !== '-h' ? 1 : 0;
+}

package/dist/runtime/column.d.ts

@@ -0,0 +1,93 @@
+export type ColumnDensity = 'compact' | 'comfortable';
+export type ColumnFiltersConfig = {
+    terms: string[];
+    hideReplies: boolean;
+    hideReposts: boolean;
+    mediaOnly: boolean;
+};
+/** What native code delivers for one column (validated there too; see waybetter-host `ColumnConfig`). */
+export type ColumnConfig = {
+    /** The column's own page (its source); chrome that only makes sense elsewhere hides only here. */
+    url: string;
+    density: ColumnDensity;
+    filters: ColumnFiltersConfig;
+    /** Count unread items and report them. */
+    unread: boolean;
+    /** Increments when the shell asks to mark everything read / jump to the first unread item. */
+    readSeq: number;
+    jumpSeq: number;
+    /** Source kind (adapter-defined), for `prepare`. */
+    kind: string;
+};
+export type ItemKind = {
+    reply: boolean;
+    repost: boolean;
+    media: boolean;
+};
+export type ColumnSite = {
+    /** Prefix of the attributes/ids this module owns (`data-<prefix>-column`, `<prefix>-column-css`). */
+    prefix: string;
+    /** The site's content column; it fills the column width. */
+    keep: string;
+    /** Always hidden in a column. */
+    hide: readonly string[];
+    /** Hidden only on the column's own page (e.g. a page title the column header repeats). */
+    sourceHide?: readonly string[];
+    /** Items for filters and the unread tracker. */
+    itemSelector: string;
+    /** The element hidden for a filtered item (default: the item itself). */
+    container?(item: Element): Element;
+    /** A stable id for an item (e.g. a post id), or null to ignore it. */
+    itemId(item: Element): string | null;
+    itemKind?(item: Element): ItemKind;
+    itemText?(item: Element): string;
+    /** Items the site announces but has not rendered yet (e.g. a "Show 12 posts" button); 0 = none. */
+    pendingCount?(doc: Document): number;
+    /** Site CSS for the column (density-aware); every rule should be scoped to `html[data-<prefix>-column]`. */
+    css?(density: ColumnDensity): string;
+    /** Navigation-only setup on the source page (e.g. select a timeline tab); true once done. */
+    prepare?(doc: Document, config: ColumnConfig): boolean;
+};
+export type ColumnHandle = {
+    set(config: unknown): void;
+    markRead(): void;
+    jumpToUnread(): void;
+    /** Current unread count (tracked + pending), 0 when off. */
+    unread(): number;
+    dispose(): void;
+};
+export type ColumnWindow = Window & typeof globalThis;
+export declare function normalizeColumnConfig(value: unknown): ColumnConfig | null;
+/** `/pattern/flags` → RegExp (flags i, m, s, u only); anything else is a plain keyword. Invalid → null. */
+export declare function parseTerm(term: string): RegExp | string | null;
+export type FilterInput = {
+    text: string;
+} & ItemKind;
+/** A predicate that says whether an item is hidden by the column's filters. */
+export declare function compileFilters(filters: ColumnFiltersConfig): (item: FilterInput) => boolean;
+/** Same page: origin, path (trailing slash ignored) and query. */
+export declare function isSourcePage(href: string, source: string): boolean;
+export type UnreadTracker = {
+    /**
+     * The rendered items, top to bottom, and which of them are on screen right now. The first
+     * non-empty observation is the baseline (read). Later, an id rendered above both the topmost
+     * read id and the topmost item on screen is unread (new, not seen yet); ids below are older
+     * items (read).
+     */
+    observe(ordered: readonly string[], onScreen: ReadonlySet<string>): void;
+    /** An item came on screen. */
+    seen(id: string): void;
+    markRead(): void;
+    count(): number;
+    /** The unread item closest to the read ones (the next one to read, scrolling up), if rendered. */
+    nextUnread(ordered: readonly string[]): string | null;
+    isUnread(id: string): boolean;
+};
+export declare function createUnreadTracker(): UnreadTracker;
+/** Pure: the module's stylesheet. Every rule is scoped to the column attribute on <html>. */
+export declare function buildColumnCss(site: ColumnSite, density: ColumnDensity): string;
+export type ColumnOptions = {
+    /** Called with the unread count (tracked + pending) whenever it changes, at most every 250 ms. */
+    onUnread?(count: number): void;
+};
+export declare function installColumnMode(win: ColumnWindow, site: ColumnSite, options?: ColumnOptions): ColumnHandle;

package/dist/runtime/column.js

@@ -0,0 +1,451 @@
+// Power User Mode, page side: a site tab that is a deck column (see shell/deckModel.ts). The shell
+// lays the column out; native code hands this module the column's config. Here the page hides the
+// site's chrome (rail, side column, floating buttons), lets the content column fill the width,
+// applies the column's density and filters, and tracks unread items. It never makes a request and
+// never clicks anything on its own except what the adapter's `prepare` does (navigation only, e.g.
+// selecting one of the site's own timeline tabs). Unread items are counted from what the site has
+// rendered: new item ids above the ones already seen, not yet scrolled into view. Only the count
+// leaves the page (the adapter reports it through its own bridge).
+import { watchDom } from "./domHub.js";
+const MAX_TERMS = 32;
+const MAX_TERM_CHARS = 200;
+const MAX_IDS = 2000;
+// ---------------------------------------------------------------------------------------------
+// Config and filters (pure)
+export function normalizeColumnConfig(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const raw = value;
+    if (typeof raw.url !== 'string' || raw.url.length > 2048)
+        return null;
+    const filters = (raw.filters && typeof raw.filters === 'object' ? raw.filters : {});
+    const terms = (Array.isArray(filters.terms) ? filters.terms : [])
+        .filter((term) => typeof term === 'string' && term.trim().length > 0 && term.length <= MAX_TERM_CHARS)
+        .slice(0, MAX_TERMS);
+    const seq = (n) => (typeof n === 'number' && Number.isFinite(n) && n >= 0 ? Math.floor(n) : 0);
+    return {
+        url: raw.url,
+        density: raw.density === 'comfortable' ? 'comfortable' : 'compact',
+        filters: { terms, hideReplies: filters.hideReplies === true, hideReposts: filters.hideReposts === true, mediaOnly: filters.mediaOnly === true },
+        unread: raw.unread !== false,
+        readSeq: seq(raw.readSeq),
+        jumpSeq: seq(raw.jumpSeq),
+        kind: typeof raw.kind === 'string' && raw.kind.length <= 24 ? raw.kind : '',
+    };
+}
+/** `/pattern/flags` → RegExp (flags i, m, s, u only); anything else is a plain keyword. Invalid → null. */
+export function parseTerm(term) {
+    const text = term.trim();
+    if (!text)
+        return null;
+    const match = /^\/(.+)\/([imsu]*)$/.exec(text);
+    if (!match)
+        return text.toLowerCase();
+    try {
+        return new RegExp(match[1], match[2].includes('i') ? match[2] : `${match[2]}i`);
+    }
+    catch {
+        return null;
+    }
+}
+/** A predicate that says whether an item is hidden by the column's filters. */
+export function compileFilters(filters) {
+    const terms = filters.terms.map(parseTerm).filter((term) => term !== null);
+    const active = terms.length > 0 || filters.hideReplies || filters.hideReposts || filters.mediaOnly;
+    if (!active)
+        return () => false;
+    return item => {
+        if (filters.hideReplies && item.reply)
+            return true;
+        if (filters.hideReposts && item.repost)
+            return true;
+        if (filters.mediaOnly && !item.media)
+            return true;
+        if (!terms.length)
+            return false;
+        const lower = item.text.toLowerCase();
+        for (const term of terms) {
+            if (typeof term === 'string' ? lower.includes(term) : term.test(item.text))
+                return true;
+        }
+        return false;
+    };
+}
+/** Same page: origin, path (trailing slash ignored) and query. */
+export function isSourcePage(href, source) {
+    try {
+        const a = new URL(href);
+        const b = new URL(source);
+        const path = (url) => url.pathname.replace(/\/+$/, '') || '/';
+        return a.origin === b.origin && path(a) === path(b) && a.search === b.search;
+    }
+    catch {
+        return false;
+    }
+}
+export function createUnreadTracker() {
+    const read = new Set();
+    const unread = new Set();
+    let baseline = false;
+    const remember = (set, id) => {
+        set.add(id);
+        if (set.size > MAX_IDS)
+            set.delete(set.values().next().value);
+    };
+    return {
+        observe(ordered, onScreen) {
+            if (!ordered.length)
+                return;
+            if (!baseline) {
+                baseline = true;
+                for (const id of ordered)
+                    remember(read, id);
+                return;
+            }
+            const topRead = ordered.findIndex(id => read.has(id));
+            const topShown = ordered.findIndex(id => onScreen.has(id));
+            const limit = topShown >= 0 && topRead >= 0 ? Math.min(topRead, topShown) : topRead;
+            ordered.forEach((id, index) => {
+                if (read.has(id) || unread.has(id)) {
+                    if (onScreen.has(id) && unread.delete(id))
+                        remember(read, id);
+                    return;
+                }
+                if (limit >= 0 && index < limit && !onScreen.has(id))
+                    remember(unread, id);
+                else
+                    remember(read, id);
+            });
+        },
+        seen(id) {
+            if (unread.delete(id))
+                remember(read, id);
+        },
+        markRead() {
+            for (const id of unread)
+                remember(read, id);
+            unread.clear();
+        },
+        count: () => unread.size,
+        nextUnread(ordered) {
+            for (let i = ordered.length - 1; i >= 0; i--)
+                if (unread.has(ordered[i]))
+                    return ordered[i];
+            return null;
+        },
+        isUnread: id => unread.has(id),
+    };
+}
+// ---------------------------------------------------------------------------------------------
+// The page module
+const names = (site) => ({
+    style: `${site.prefix}-column-css`,
+    column: `data-${site.prefix}-column`,
+    home: `data-${site.prefix}-column-home`,
+    density: `data-${site.prefix}-density`,
+    filtered: `data-${site.prefix}-filtered`,
+    unread: `data-${site.prefix}-unread`,
+});
+/** Pure: the module's stylesheet. Every rule is scoped to the column attribute on <html>. */
+export function buildColumnCss(site, density) {
+    const n = names(site);
+    const root = `html[${n.column}]`;
+    const rules = [
+        site.hide.length ? `${root} :is(${site.hide.join(', ')}) { display: none !important; }` : '',
+        site.sourceHide?.length ? `${root}[${n.home}] :is(${site.sourceHide.join(', ')}) { display: none !important; }` : '',
+        `${root} ${site.keep} { width: 100% !important; max-width: none !important; min-width: 0 !important; flex: 1 1 auto !important; }`,
+        `${root} [${n.filtered}] { display: none !important; }`,
+        // Narrow columns scroll without a scrollbar (the deck header shows where you are: unread count).
+        `${root} { scrollbar-width: none; }`,
+        site.css?.(density) ?? '',
+    ];
+    return rules.filter(Boolean).join('\n');
+}
+export function installColumnMode(win, site, options = {}) {
+    const doc = win.document;
+    const n = names(site);
+    const root = () => doc.documentElement;
+    let config = null;
+    let matcher = () => false;
+    let tracker = createUnreadTracker();
+    let watch = null;
+    let observer = null;
+    const observed = new WeakSet();
+    const ids = new WeakMap();
+    let prepared = false;
+    let lastReported = -1;
+    let reportTimer = 0;
+    let lastUrl = '';
+    let lastSeq = { read: -1, jump: -1 };
+    const onSource = () => !!config && isSourcePage(win.location.href, config.url);
+    const ensureStyle = () => {
+        if (!config)
+            return;
+        let style = doc.getElementById(n.style);
+        if (!style) {
+            const parent = doc.head || root();
+            if (!parent)
+                return;
+            style = doc.createElement('style');
+            style.id = n.style;
+            parent.appendChild(style);
+        }
+        const css = buildColumnCss(site, config.density);
+        if (style.textContent !== css)
+            style.textContent = css;
+    };
+    const kindOf = (item) => site.itemKind?.(item) ?? { reply: false, repost: false, media: false };
+    const textOf = (item) => site.itemText?.(item) ?? item.textContent ?? '';
+    /** The column is on screen: the page is visible and the webview has a real size (hosts shrink a
+     * hidden tab webview to a pixel, and not every engine reports it as hidden). */
+    const shown = () => doc.visibilityState !== 'hidden' && win.innerWidth > 40 && win.innerHeight > 40;
+    const onScreen = (item) => {
+        if (!shown())
+            return false;
+        const box = item.getBoundingClientRect();
+        const height = win.innerHeight || doc.documentElement.clientHeight;
+        // Mostly in view: its top is on screen and at least 40 px (or all of it) is visible.
+        return box.bottom > 0 && box.top < height && Math.min(box.bottom, height) - Math.max(box.top, 0) >= Math.min(40, box.height);
+    };
+    const pending = () => {
+        try {
+            return Math.max(0, Math.floor(site.pendingCount?.(doc) ?? 0));
+        }
+        catch {
+            return 0;
+        }
+    };
+    const report = () => {
+        if (!options.onUnread)
+            return;
+        const count = config?.unread ? Math.min(999, tracker.count() + pending()) : 0;
+        if (count === lastReported)
+            return;
+        if (reportTimer)
+            return;
+        reportTimer = win.setTimeout(() => {
+            reportTimer = 0;
+            const now = config?.unread ? Math.min(999, tracker.count() + pending()) : 0;
+            if (now === lastReported)
+                return;
+            lastReported = now;
+            try {
+                options.onUnread?.(now);
+            }
+            catch { /* reporting is best effort */ }
+        }, 250);
+    };
+    const ensureObserver = () => {
+        if (observer || typeof win.IntersectionObserver !== 'function')
+            return;
+        observer = new win.IntersectionObserver(entries => {
+            if (!shown())
+                return;
+            let changed = false;
+            for (const entry of entries) {
+                if (!entry.isIntersecting)
+                    continue;
+                const id = ids.get(entry.target);
+                if (id && tracker.isUnread(id)) {
+                    tracker.seen(id);
+                    changed = true;
+                }
+                if (id)
+                    entry.target.removeAttribute(n.unread);
+            }
+            if (changed)
+                report();
+        }, { threshold: [0, 0.5, 1] });
+    };
+    const items = () => Array.from(doc.querySelectorAll(site.itemSelector));
+    const scan = () => {
+        if (!config)
+            return;
+        const html = root();
+        if (!html)
+            return;
+        // A config delivered at document start arrives before the parser has created <html>.
+        if (!html.hasAttribute(n.column))
+            html.setAttribute(n.column, '');
+        if (html.getAttribute(n.density) !== config.density)
+            html.setAttribute(n.density, config.density);
+        ensureStyle();
+        const source = onSource();
+        if (source)
+            html.setAttribute(n.home, '');
+        else
+            html.removeAttribute(n.home);
+        if (win.location.href !== lastUrl) {
+            lastUrl = win.location.href;
+            prepared = false;
+        }
+        if (source && !prepared && site.prepare) {
+            try {
+                prepared = site.prepare(doc, config);
+            }
+            catch {
+                prepared = true;
+            }
+        }
+        const list = items();
+        const ordered = [];
+        const visible = new Set();
+        for (const item of list) {
+            const container = site.container?.(item) ?? item;
+            let hidden = false;
+            if (source) {
+                try {
+                    hidden = matcher({ text: textOf(item), ...kindOf(item) });
+                }
+                catch {
+                    hidden = false;
+                }
+            }
+            if (hidden)
+                container.setAttribute(n.filtered, '');
+            else if (container.hasAttribute(n.filtered))
+                container.removeAttribute(n.filtered);
+            if (!source || !config.unread || hidden)
+                continue;
+            let id = null;
+            try {
+                id = site.itemId(item);
+            }
+            catch {
+                id = null;
+            }
+            if (!id || ordered.includes(id))
+                continue;
+            ids.set(item, id);
+            ordered.push(id);
+            if (onScreen(item))
+                visible.add(id);
+            ensureObserver();
+            if (observer && !observed.has(item)) {
+                observed.add(item);
+                observer.observe(item);
+            }
+        }
+        if (source && config.unread) {
+            tracker.observe(ordered, visible);
+            for (const item of list) {
+                const id = ids.get(item);
+                if (!id)
+                    continue;
+                if (tracker.isUnread(id))
+                    item.setAttribute(n.unread, '');
+                else if (item.hasAttribute(n.unread))
+                    item.removeAttribute(n.unread);
+            }
+        }
+        report();
+    };
+    const onKey = (event) => {
+        if (!config || !event.altKey || event.ctrlKey || event.metaKey || event.shiftKey)
+            return;
+        const key = event.key.toLowerCase();
+        if (key !== 'r' && key !== 'u')
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        if (key === 'r')
+            handle.markRead();
+        else
+            handle.jumpToUnread();
+    };
+    const onVisibility = () => { if (shown())
+        watch?.schedule(); };
+    const start = () => {
+        if (watch)
+            return;
+        watch = watchDom(win, scan, { phase: 'write' });
+        win.addEventListener('keydown', onKey, true);
+        doc.addEventListener('visibilitychange', onVisibility);
+        win.addEventListener('resize', onVisibility);
+        win.addEventListener('scroll', onScroll, { passive: true });
+    };
+    let scrollFrame = 0;
+    const onScroll = () => {
+        if (scrollFrame)
+            return;
+        scrollFrame = win.requestAnimationFrame(() => { scrollFrame = 0; report(); });
+    };
+    const stop = () => {
+        watch?.dispose();
+        watch = null;
+        observer?.disconnect();
+        observer = null;
+        win.removeEventListener('keydown', onKey, true);
+        doc.removeEventListener('visibilitychange', onVisibility);
+        win.removeEventListener('resize', onVisibility);
+        win.removeEventListener('scroll', onScroll);
+        if (reportTimer) {
+            win.clearTimeout(reportTimer);
+            reportTimer = 0;
+        }
+        const html = root();
+        html?.removeAttribute(n.column);
+        html?.removeAttribute(n.home);
+        html?.removeAttribute(n.density);
+        doc.getElementById(n.style)?.remove();
+        for (const el of Array.from(doc.querySelectorAll(`[${n.filtered}], [${n.unread}]`))) {
+            el.removeAttribute(n.filtered);
+            el.removeAttribute(n.unread);
+        }
+    };
+    const handle = {
+        set(value) {
+            const next = normalizeColumnConfig(value);
+            if (!next) {
+                if (config) {
+                    config = null;
+                    stop();
+                    lastReported = -1;
+                    options.onUnread?.(0);
+                }
+                return;
+            }
+            const first = !config;
+            const sourceChanged = !!config && config.url !== next.url;
+            config = next;
+            matcher = compileFilters(next.filters);
+            if (first || sourceChanged) {
+                tracker = createUnreadTracker();
+                prepared = false;
+            }
+            const html = root();
+            html?.setAttribute(n.column, '');
+            html?.setAttribute(n.density, next.density);
+            if (!first && lastSeq.read >= 0 && next.readSeq !== lastSeq.read)
+                handle.markRead();
+            if (!first && lastSeq.jump >= 0 && next.jumpSeq !== lastSeq.jump)
+                handle.jumpToUnread();
+            lastSeq = { read: next.readSeq, jump: next.jumpSeq };
+            ensureStyle();
+            start();
+            watch?.schedule();
+            if (!next.unread)
+                report();
+        },
+        markRead() {
+            tracker.markRead();
+            for (const el of Array.from(doc.querySelectorAll(`[${n.unread}]`)))
+                el.removeAttribute(n.unread);
+            report();
+        },
+        jumpToUnread() {
+            const list = items();
+            const ordered = list.map(item => ids.get(item)).filter((id) => !!id);
+            const target = tracker.nextUnread(ordered);
+            const element = target ? list.find(item => ids.get(item) === target) : null;
+            if (element)
+                (site.container?.(element) ?? element).scrollIntoView({ block: 'start' });
+            else if (pending() > 0)
+                win.scrollTo({ top: 0 });
+        },
+        unread: () => (config?.unread ? Math.min(999, tracker.count() + pending()) : 0),
+        dispose() { config = null; stop(); },
+    };
+    return handle;
+}
+//# sourceMappingURL=column.js.map