@khorsheed/dsh-reader 0.3.0 → 0.3.1

package/lib/types/media-host.d.ts

@@ -0,0 +1,91 @@
+import { type ReaderMedia } from './media.ts';
+import type { XiaoyuzhouEpisode } from './xiaoyuzhou.ts';
+import { YtDlp, type YtDlpInfo } from './ytdlp.ts';
+/** What a video's captions came to, remembered per entry. */
+export interface CaptionRecord {
+    /** `local`: transcribed on this machine (the platform had no captions). */
+    readonly state: 'platform' | 'none' | 'local';
+    readonly language?: string;
+    readonly checkedAt: string;
+    /** How many voices a local transcript has (1: the probe heard one; ≥ 2: paragraphs carry `data-spk`). */
+    readonly speakers?: number;
+    /** The reader's names for the speakers, by index (`0` → 主持人). */
+    readonly names?: Readonly<Record<string, string>>;
+}
+/**
+ * The synthetic page a media link is stored as.
+ *
+ * @param page - what the page says.
+ */
+export declare function syntheticPage(page: {
+    title: string;
+    media: ReaderMedia;
+    descriptionText?: string;
+    descriptionHtml?: string;
+    author?: string;
+    publishedAt?: string;
+}): string;
+/**
+ * A video's synthetic page from its yt-dlp metadata.
+ *
+ * @param info - the metadata.
+ * @param provider - which platform.
+ * @param id - the platform's video id.
+ */
+export declare function videoPage(info: YtDlpInfo, provider: 'youtube' | 'bilibili', id: string): string;
+/**
+ * A Xiaoyuzhou episode's synthetic page.
+ *
+ * @param episode - the parsed episode.
+ */
+export declare function episodePage(episode: XiaoyuzhouEpisode): string;
+/**
+ * A YouTube channel's newest videos as an RSS document (YouTube's own channel
+ * feed answers 404 — measured 2026-10-20). Each item links the watch page, so
+ * the browser half reads it as a video; the thumbnail rides `media:thumbnail`.
+ *
+ * @param channel - the yt-dlp flat listing.
+ * @param pageUrl - the channel URL.
+ */
+export declare function channelRss(channel: {
+    title?: string;
+    entries: readonly YtDlpInfo[];
+}, pageUrl: string): string;
+/** A synthetic page's display name for the source: its author (the channel / podcast), else its title. */
+export declare function syntheticLabel(raw: string): string | undefined;
+/**
+ * Where a share short link leads (b23.tv → bilibili.com/video/BV…). curl
+ * follows the redirect chain and honors the deployment's proxy environment.
+ *
+ * @param url - the short link.
+ */
+export declare function resolveShortLink(url: string): Promise<string>;
+/** The host's media helper: yt-dlp plus the caption record. */
+export declare class ReaderMediaHost {
+    private readonly stateRoot;
+    readonly ytdlp: YtDlp;
+    private readonly file;
+    private records;
+    /**
+     * @param stateRoot - the reader's state root.
+     * @param ytdlpPath - a deployment-configured yt-dlp, which wins over the managed one.
+     */
+    constructor(stateRoot: string, ytdlpPath?: string);
+    /** The caption records, read once. */
+    private load;
+    /** What is known about an entry's captions. */
+    captions(entryId: string): CaptionRecord | undefined;
+    /** Remember what an entry's captions came to. */
+    remember(entryId: string, record: CaptionRecord): void;
+    /**
+     * A video's transcript from its platform captions.
+     *
+     * @param url - the video page.
+     * @returns the transcript markup and its language, or `none` when the video has no captions.
+     */
+    transcript(url: string): Promise<{
+        html: string;
+        language: string;
+    } | 'none'>;
+}
+//# sourceMappingURL=media-host.d.ts.map

package/lib/types/media-host.js

@@ -0,0 +1,230 @@
+/**
+ * The host half of video and audio entries: the pages a media link becomes,
+ * the feeds a channel or podcast becomes, and the transcript a video reads as.
+ *
+ * - A single video (YouTube, Bilibili) or Xiaoyuzhou episode is stored as a
+ *   `link` source whose payload is a SYNTHETIC page: title, description,
+ *   thumbnail, and a `<meta name="dsh-reader:media">` carrying the media
+ *   description the browser half reads (`readMediaMeta`). Every other part of
+ *   the reader then treats it as a saved link.
+ * - A YouTube channel resolves to YouTube's own channel feed; a Xiaoyuzhou
+ *   podcast page becomes an RSS document (`xiaoyuzhou.ts`).
+ * - A video's transcript comes from the platform's captions via yt-dlp,
+ *   merged into timed paragraphs (`captions.ts`). Whether a video has
+ *   captions is remembered in `media.json`, so a caption-less video does not
+ *   cost a yt-dlp run on every open.
+ *
+ * @module @khorsheed/dsh-reader/media-host
+ */
+import { execFile } from 'node:child_process';
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { mergeCues, renderTranscript } from "./captions.js";
+import { MEDIA_META_NAME } from "./media.js";
+import { chooseCaptionTrack, YtDlp } from "./ytdlp.js";
+/** Escape text for HTML content and attributes. */
+function escapeHtml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+/** A plain-text description as paragraphs. */
+function paragraphs(text) {
+    return text.split(/\n{2,}/).map(block => block.trim()).filter(block => block !== '')
+        .map(block => `<p>${escapeHtml(block).replace(/\n/g, '<br>')}</p>`).join('\n');
+}
+/**
+ * The synthetic page a media link is stored as.
+ *
+ * @param page - what the page says.
+ */
+export function syntheticPage(page) {
+    const body = page.descriptionHtml ?? (page.descriptionText === undefined ? '' : paragraphs(page.descriptionText));
+    const plain = (page.descriptionText ?? page.descriptionHtml?.replace(/<[^>]+>/g, ' ') ?? '').replace(/\s+/g, ' ').trim().slice(0, 300);
+    return [
+        '<!doctype html><html><head><meta charset="utf-8">',
+        `<title>${escapeHtml(page.title)}</title>`,
+        `<meta property="og:title" content="${escapeHtml(page.title)}">`,
+        plain === '' ? '' : `<meta name="description" content="${escapeHtml(plain)}">`,
+        page.media.thumbnail === undefined ? '' : `<meta property="og:image" content="${escapeHtml(page.media.thumbnail)}">`,
+        page.author === undefined ? '' : `<meta name="author" content="${escapeHtml(page.author)}">`,
+        page.publishedAt === undefined ? '' : `<meta property="article:published_time" content="${escapeHtml(page.publishedAt)}">`,
+        `<meta name="${MEDIA_META_NAME}" content="${escapeHtml(JSON.stringify(page.media))}">`,
+        '</head><body><article>',
+        `<h1>${escapeHtml(page.title)}</h1>`,
+        body,
+        '</article></body></html>',
+    ].filter(line => line !== '').join('\n');
+}
+/** A yt-dlp `upload_date` (`YYYYMMDD`) or timestamp as ISO-8601. */
+function publishedOf(info) {
+    if (typeof info.timestamp === 'number')
+        return new Date(info.timestamp * 1000).toISOString();
+    const day = /^(\d{4})(\d{2})(\d{2})$/.exec(info.upload_date ?? '');
+    return day === null ? undefined : `${day[1]}-${day[2]}-${day[3]}T00:00:00.000Z`;
+}
+/**
+ * A video's synthetic page from its yt-dlp metadata.
+ *
+ * @param info - the metadata.
+ * @param provider - which platform.
+ * @param id - the platform's video id.
+ */
+export function videoPage(info, provider, id) {
+    const published = publishedOf(info);
+    const author = info.uploader ?? info.channel;
+    return syntheticPage({
+        title: info.title ?? id,
+        media: {
+            kind: 'video',
+            provider,
+            ref: id,
+            ...(typeof info.duration === 'number' ? { durationSec: Math.round(info.duration) } : {}),
+            ...(info.thumbnail === undefined ? {} : { thumbnail: info.thumbnail }),
+        },
+        ...(info.description === undefined ? {} : { descriptionText: info.description }),
+        ...(author === undefined ? {} : { author }),
+        ...(published === undefined ? {} : { publishedAt: published }),
+    });
+}
+/**
+ * A Xiaoyuzhou episode's synthetic page.
+ *
+ * @param episode - the parsed episode.
+ */
+export function episodePage(episode) {
+    return syntheticPage({
+        title: episode.title,
+        media: {
+            kind: 'audio',
+            provider: 'xiaoyuzhou',
+            ref: episode.audio,
+            ...(episode.durationSec === undefined ? {} : { durationSec: episode.durationSec }),
+            ...(episode.image === undefined ? {} : { thumbnail: episode.image }),
+        },
+        ...(episode.notesHtml === undefined ? {} : { descriptionHtml: episode.notesHtml }),
+        ...(episode.podcastTitle === undefined ? {} : { author: episode.podcastTitle }),
+        ...(episode.publishedAt === undefined ? {} : { publishedAt: episode.publishedAt }),
+    });
+}
+/** Escape text for XML. */
+function xml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+/**
+ * A YouTube channel's newest videos as an RSS document (YouTube's own channel
+ * feed answers 404 — measured 2026-10-20). Each item links the watch page, so
+ * the browser half reads it as a video; the thumbnail rides `media:thumbnail`.
+ *
+ * @param channel - the yt-dlp flat listing.
+ * @param pageUrl - the channel URL.
+ */
+export function channelRss(channel, pageUrl) {
+    const items = channel.entries.flatMap(entry => {
+        if (entry.id === undefined || entry.title === undefined)
+            return [];
+        const published = publishedOf(entry);
+        return [[
+                '<item>',
+                `<title>${xml(entry.title)}</title>`,
+                `<link>https://www.youtube.com/watch?v=${xml(entry.id)}</link>`,
+                `<guid isPermaLink="false">yt:video:${xml(entry.id)}</guid>`,
+                published === undefined ? '' : `<pubDate>${new Date(published).toUTCString()}</pubDate>`,
+                entry.thumbnail === undefined ? '' : `<media:thumbnail url="${xml(entry.thumbnail)}"/>`,
+                '</item>',
+            ].filter(line => line !== '').join('')];
+    });
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<rss version="2.0" xmlns:media="http://search.yahoo.com/mrss/"><channel>',
+        `<title>${xml(channel.title ?? pageUrl)}</title>`,
+        `<link>${xml(pageUrl)}</link>`,
+        ...items,
+        '</channel></rss>',
+    ].join('\n');
+}
+/** A synthetic page's display name for the source: its author (the channel / podcast), else its title. */
+export function syntheticLabel(raw) {
+    const author = /<meta name="author" content="([^"]*)"/.exec(raw)?.[1];
+    const title = /<title>([^<]*)<\/title>/.exec(raw)?.[1];
+    const value = author ?? title;
+    return value === undefined ? undefined : value.replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+}
+/**
+ * Where a share short link leads (b23.tv → bilibili.com/video/BV…). curl
+ * follows the redirect chain and honors the deployment's proxy environment.
+ *
+ * @param url - the short link.
+ */
+export function resolveShortLink(url) {
+    return new Promise((resolve, reject) => {
+        execFile('curl', ['-sL', '-m', '20', '-A', 'Mozilla/5.0', '-o', '/dev/null', '-w', '%{url_effective}', url], { timeout: 30_000, env: process.env }, (error, stdout) => {
+            if (error !== null) {
+                reject(error);
+                return;
+            }
+            resolve(String(stdout).trim());
+        });
+    });
+}
+/** The host's media helper: yt-dlp plus the caption record. */
+export class ReaderMediaHost {
+    stateRoot;
+    ytdlp;
+    file;
+    records;
+    /**
+     * @param stateRoot - the reader's state root.
+     * @param ytdlpPath - a deployment-configured yt-dlp, which wins over the managed one.
+     */
+    constructor(stateRoot, ytdlpPath) {
+        this.stateRoot = stateRoot;
+        this.ytdlp = new YtDlp(stateRoot, ytdlpPath);
+        this.file = join(stateRoot, 'media.json');
+    }
+    /** The caption records, read once. */
+    load() {
+        if (this.records !== undefined)
+            return this.records;
+        try {
+            this.records = JSON.parse(readFileSync(this.file, 'utf8'));
+        }
+        catch {
+            this.records = {};
+        }
+        return this.records;
+    }
+    /** What is known about an entry's captions. */
+    captions(entryId) {
+        return this.load()[entryId];
+    }
+    /** Remember what an entry's captions came to. */
+    remember(entryId, record) {
+        const records = { ...this.load(), [entryId]: record };
+        this.records = records;
+        try {
+            mkdirSync(this.stateRoot, { recursive: true });
+            const temporary = `${this.file}.${process.pid}.tmp`;
+            writeFileSync(temporary, `${JSON.stringify(records, null, 2)}\n`);
+            renameSync(temporary, this.file);
+        }
+        catch {
+            // Memory-only: the record still saves this process the repeat run.
+            rmSync(`${this.file}.${process.pid}.tmp`, { force: true });
+        }
+    }
+    /**
+     * A video's transcript from its platform captions.
+     *
+     * @param url - the video page.
+     * @returns the transcript markup and its language, or `none` when the video has no captions.
+     */
+    async transcript(url) {
+        const info = await this.ytdlp.info(url);
+        const track = chooseCaptionTrack(info);
+        if (track === undefined)
+            return 'none';
+        const segments = mergeCues(await this.ytdlp.captions(url, track));
+        if (segments.length === 0)
+            return 'none';
+        return { html: renderTranscript(segments), language: track.lang.replace(/-orig$/, '') };
+    }
+}

package/lib/types/media.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Video and audio entries: what kind of media a link or a feed item is, and
+ * how the browser plays it.
+ *
+ * The kind is decided per ITEM, never per source (the 2026-10-20 decision): a
+ * feed may carry articles, audio and video side by side. The signals, best
+ * first, are a feed enclosure's MIME type, a link the resolvers recognize
+ * (YouTube, Bilibili, Xiaoyuzhou), and — on the host, where pages are fetched
+ * — a page whose main content is a player. A page with real prose stays an
+ * article even when it embeds a video.
+ *
+ * Pure and shared by both halves.
+ *
+ * @module @khorsheed/dsh-reader/media
+ */
+/** Where a media entry plays from. */
+export type ReaderMediaProvider = 'youtube' | 'bilibili' | 'xiaoyuzhou' | 'enclosure';
+/** A media entry's description, carried on the entry. */
+export interface ReaderMedia {
+    readonly kind: 'video' | 'audio';
+    readonly provider: ReaderMediaProvider;
+    /** The platform's id (YouTube video id, Bilibili BV id) or the audio URL. */
+    readonly ref: string;
+    readonly durationSec?: number;
+    readonly thumbnail?: string;
+}
+/** A recognized media link. */
+export interface MediaLink {
+    readonly provider: 'youtube' | 'bilibili' | 'xiaoyuzhou';
+    readonly kind: 'video' | 'audio' | 'channel' | 'podcast';
+    /** Video id / BV id / episode id / channel handle-or-id / podcast id. */
+    readonly id: string;
+}
+/**
+ * Recognize a media link from its URL alone.
+ *
+ * @param input - any URL.
+ * @returns the link, or `undefined` for anything else.
+ */
+export declare function mediaLink(input: string): MediaLink | undefined;
+/** True for a share short link that must be resolved before it can be recognized. */
+export declare function isShortMediaLink(input: string): boolean;
+/**
+ * The clean address of a recognized video link: the platform's canonical page,
+ * without the share-tracking parameters a resolved short link drags along.
+ *
+ * @param input - a video URL.
+ */
+export declare function canonicalMediaUrl(input: string): string | undefined;
+/**
+ * The media kind of a feed enclosure, from its MIME type (or, when a feed
+ * omits it, from the file extension).
+ *
+ * @param url - the enclosure URL.
+ * @param type - the declared MIME type, when present.
+ */
+export declare function enclosureKind(url: string, type?: string): 'video' | 'audio' | undefined;
+/**
+ * The media an entry plays, from what the feed said and where it links.
+ *
+ * @param entry - the entry's link and its enclosure, when the feed had one.
+ */
+export declare function entryMedia(entry: {
+    link?: string;
+    enclosure?: {
+        url: string;
+        type?: string;
+        durationSec?: number;
+        image?: string;
+    };
+}): ReaderMedia | undefined;
+/**
+ * The embed URL a video plays in, starting at `start` seconds.
+ *
+ * YouTube's embed takes postMessage commands (`enablejsapi=1`, with the
+ * embedding origin); Bilibili's has no control channel, so a seek reloads it
+ * with `t` (measured 2026-10-20).
+ *
+ * @param media - the entry's media.
+ * @param start - where to start (seconds).
+ * @param origin - the embedding page's origin (YouTube checks it).
+ */
+export declare function embedUrl(media: ReaderMedia, start: number, origin: string): string | undefined;
+/**
+ * A link to the original at a moment (what notes and canvas cards carry).
+ *
+ * @param link - the entry's link.
+ * @param seconds - the moment.
+ */
+export declare function linkAt(link: string, seconds: number): string;
+/** The `<meta name>` a media link's synthetic page carries its description in. */
+export declare const MEDIA_META_NAME = "dsh-reader:media";
+/**
+ * The media description a synthetic page carries (see `media-host.ts`).
+ *
+ * @param raw - a stored link payload.
+ * @returns the media, or `undefined` for an ordinary page.
+ */
+export declare function readMediaMeta(raw: string): ReaderMedia | undefined;
+//# sourceMappingURL=media.d.ts.map

package/lib/types/media.js

@@ -0,0 +1,207 @@
+/**
+ * Video and audio entries: what kind of media a link or a feed item is, and
+ * how the browser plays it.
+ *
+ * The kind is decided per ITEM, never per source (the 2026-10-20 decision): a
+ * feed may carry articles, audio and video side by side. The signals, best
+ * first, are a feed enclosure's MIME type, a link the resolvers recognize
+ * (YouTube, Bilibili, Xiaoyuzhou), and — on the host, where pages are fetched
+ * — a page whose main content is a player. A page with real prose stays an
+ * article even when it embeds a video.
+ *
+ * Pure and shared by both halves.
+ *
+ * @module @khorsheed/dsh-reader/media
+ */
+/**
+ * Recognize a media link from its URL alone.
+ *
+ * @param input - any URL.
+ * @returns the link, or `undefined` for anything else.
+ */
+export function mediaLink(input) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        return undefined;
+    }
+    const host = url.hostname.replace(/^(www|m)\./, '');
+    if (host === 'youtube.com' || host === 'music.youtube.com') {
+        const v = url.searchParams.get('v');
+        if (url.pathname === '/watch' && v !== null && /^[\w-]{6,}$/.test(v))
+            return { provider: 'youtube', kind: 'video', id: v };
+        const short = /^\/(?:shorts|live|embed)\/([\w-]{6,})/.exec(url.pathname);
+        if (short !== null)
+            return { provider: 'youtube', kind: 'video', id: short[1] };
+        const channel = /^\/(@[\w.-]+|channel\/UC[\w-]{10,}|c\/[\w.-]+|user\/[\w.-]+)\/?$/.exec(url.pathname.replace(/\/(videos|featured|streams)\/?$/, '/'));
+        if (channel !== null)
+            return { provider: 'youtube', kind: 'channel', id: channel[1] };
+        return undefined;
+    }
+    if (host === 'youtu.be') {
+        const id = url.pathname.slice(1);
+        return /^[\w-]{6,}$/.test(id) ? { provider: 'youtube', kind: 'video', id } : undefined;
+    }
+    if (host === 'bilibili.com' || host === 'b23.tv') {
+        const bv = /\/video\/(BV[0-9A-Za-z]{10})/.exec(url.pathname);
+        if (bv !== null)
+            return { provider: 'bilibili', kind: 'video', id: bv[1] };
+        return undefined;
+    }
+    if (host === 'xiaoyuzhoufm.com') {
+        const episode = /^\/episode\/([0-9a-f]{24})/.exec(url.pathname);
+        if (episode !== null)
+            return { provider: 'xiaoyuzhou', kind: 'audio', id: episode[1] };
+        const podcast = /^\/podcast\/([0-9a-f]{24})/.exec(url.pathname);
+        if (podcast !== null)
+            return { provider: 'xiaoyuzhou', kind: 'podcast', id: podcast[1] };
+    }
+    return undefined;
+}
+/** Hosts whose links are only redirects to a media page (Bilibili's share links). */
+const SHORT_LINK_HOSTS = new Set(['b23.tv', 'bili2233.cn']);
+/** True for a share short link that must be resolved before it can be recognized. */
+export function isShortMediaLink(input) {
+    try {
+        return SHORT_LINK_HOSTS.has(new URL(input).hostname.replace(/^www\./, ''));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The clean address of a recognized video link: the platform's canonical page,
+ * without the share-tracking parameters a resolved short link drags along.
+ *
+ * @param input - a video URL.
+ */
+export function canonicalMediaUrl(input) {
+    const link = mediaLink(input);
+    if (link?.provider === 'bilibili' && link.kind === 'video') {
+        const page = new URL(input).searchParams.get('p');
+        return `https://www.bilibili.com/video/${link.id}/${page !== null && page !== '1' ? `?p=${encodeURIComponent(page)}` : ''}`;
+    }
+    if (link?.provider === 'youtube' && link.kind === 'video')
+        return `https://www.youtube.com/watch?v=${link.id}`;
+    return undefined;
+}
+/**
+ * The media kind of a feed enclosure, from its MIME type (or, when a feed
+ * omits it, from the file extension).
+ *
+ * @param url - the enclosure URL.
+ * @param type - the declared MIME type, when present.
+ */
+export function enclosureKind(url, type) {
+    const mime = (type ?? '').toLowerCase();
+    if (mime.startsWith('audio/'))
+        return 'audio';
+    if (mime.startsWith('video/'))
+        return 'video';
+    const path = url.toLowerCase().split('?')[0] ?? '';
+    if (/\.(mp3|m4a|aac|ogg|oga|opus|wav|flac)$/.test(path))
+        return 'audio';
+    if (/\.(mp4|m4v|mov|webm)$/.test(path))
+        return 'video';
+    return undefined;
+}
+/**
+ * The media an entry plays, from what the feed said and where it links.
+ *
+ * @param entry - the entry's link and its enclosure, when the feed had one.
+ */
+export function entryMedia(entry) {
+    const linked = entry.link === undefined ? undefined : mediaLink(entry.link);
+    if (linked !== undefined && linked.kind === 'video') {
+        return { kind: 'video', provider: linked.provider, ref: linked.id, ...(entry.enclosure?.image === undefined ? {} : { thumbnail: entry.enclosure.image }) };
+    }
+    if (entry.enclosure !== undefined) {
+        const kind = enclosureKind(entry.enclosure.url, entry.enclosure.type);
+        if (kind !== undefined) {
+            return {
+                kind,
+                provider: 'enclosure',
+                ref: entry.enclosure.url,
+                ...(entry.enclosure.durationSec === undefined ? {} : { durationSec: entry.enclosure.durationSec }),
+                ...(entry.enclosure.image === undefined ? {} : { thumbnail: entry.enclosure.image }),
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * The embed URL a video plays in, starting at `start` seconds.
+ *
+ * YouTube's embed takes postMessage commands (`enablejsapi=1`, with the
+ * embedding origin); Bilibili's has no control channel, so a seek reloads it
+ * with `t` (measured 2026-10-20).
+ *
+ * @param media - the entry's media.
+ * @param start - where to start (seconds).
+ * @param origin - the embedding page's origin (YouTube checks it).
+ */
+export function embedUrl(media, start, origin) {
+    const t = Math.max(0, Math.floor(start));
+    if (media.provider === 'youtube') {
+        return `https://www.youtube.com/embed/${encodeURIComponent(media.ref)}?enablejsapi=1&playsinline=1&rel=0&start=${String(t)}&origin=${encodeURIComponent(origin)}`;
+    }
+    if (media.provider === 'bilibili') {
+        return `https://player.bilibili.com/player.html?bvid=${encodeURIComponent(media.ref)}&t=${String(t)}&danmaku=0&high_quality=1&autoplay=${t > 0 ? '1' : '0'}`;
+    }
+    return undefined;
+}
+/**
+ * A link to the original at a moment (what notes and canvas cards carry).
+ *
+ * @param link - the entry's link.
+ * @param seconds - the moment.
+ */
+export function linkAt(link, seconds) {
+    const media = mediaLink(link);
+    const t = Math.max(0, Math.floor(seconds));
+    if (media?.provider === 'youtube' || media?.provider === 'bilibili') {
+        try {
+            const url = new URL(link);
+            url.searchParams.set('t', media.provider === 'youtube' ? `${String(t)}s` : String(t));
+            return url.toString();
+        }
+        catch {
+            return link;
+        }
+    }
+    return link;
+}
+/** The `<meta name>` a media link's synthetic page carries its description in. */
+export const MEDIA_META_NAME = 'dsh-reader:media';
+/** Decode the few entities an attribute value carries. */
+function unescapeAttribute(value) {
+    return value.replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&#39;/g, "'").replace(/&amp;/g, '&');
+}
+/**
+ * The media description a synthetic page carries (see `media-host.ts`).
+ *
+ * @param raw - a stored link payload.
+ * @returns the media, or `undefined` for an ordinary page.
+ */
+export function readMediaMeta(raw) {
+    const match = new RegExp(`<meta name="${MEDIA_META_NAME}" content="([^"]*)"`).exec(raw);
+    if (match === null)
+        return undefined;
+    try {
+        const value = JSON.parse(unescapeAttribute(match[1]));
+        if ((value.kind !== 'video' && value.kind !== 'audio') || typeof value.ref !== 'string' || typeof value.provider !== 'string')
+            return undefined;
+        return {
+            kind: value.kind,
+            provider: value.provider,
+            ref: value.ref,
+            ...(typeof value.durationSec === 'number' ? { durationSec: value.durationSec } : {}),
+            ...(typeof value.thumbnail === 'string' ? { thumbnail: value.thumbnail } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}