@dxos/plugin-magazine 0.10.0 → 0.11.1

package/dist/lib/chunk-sources.mjs

@@ -0,0 +1,576 @@
+import { r as makeSnippet, t as decodeEntities } from "./chunk-text.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { Subscription } from "#types";
+import * as Data from "effect/Data";
+import Defuddle from "defuddle/full";
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import { XMLParser } from "fast-xml-parser";
+import { normalizeText } from "@dxos/markdown";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Schedule from "effect/Schedule";
+//#region src/operations/extraction/article.ts
+var isDocumentParserAvailable = () => typeof DOMParser !== "undefined";
+var collectImageUrls = (lead, contentHtml) => {
+	const seen = /* @__PURE__ */ new Set();
+	const urls = [];
+	const push = (url) => {
+		if (!url || url.startsWith("data:") || seen.has(url)) return;
+		seen.add(url);
+		urls.push(url);
+	};
+	push(lead);
+	const imgRegex = /<img\b[^>]+src=["']([^"']+)["']/gi;
+	let match;
+	while ((match = imgRegex.exec(contentHtml)) != null) push(match[1]);
+	return urls;
+};
+/** Substring patterns on class/id that mark a block as chrome. */
+var CHROME_CLASS_PATTERN = /(?:^|[\s_-])(?:tag|topic|related|recirc|footer|sidebar|widget|share|social|comments?|disqus|recommend|more[-_]from|read[-_]next|outbrain|taboola)(?:[\s_-]|$)/i;
+/** Hrefs that point to tag/category/related routes. */
+var CHROME_HREF_PATTERN = /\/(?:tags?|topics?|categor(?:y|ies)|authors?|related|recommended)\//i;
+var isHeading = (el) => /^H[1-6]$/i.test(el.tagName);
+/** A `<ul>` / `<ol>` whose items are essentially a single link each. */
+var isLinkOnlyList = (el) => {
+	if (el.tagName !== "UL" && el.tagName !== "OL") return false;
+	const items = Array.from(el.children).filter((child) => child.tagName === "LI");
+	if (items.length === 0) return false;
+	return items.every((li) => {
+		const links = li.querySelectorAll("a");
+		if (links.length !== 1) return false;
+		const text = (li.textContent ?? "").trim();
+		const linkText = (links[0].textContent ?? "").trim();
+		return text.length > 0 && Math.abs(text.length - linkText.length) <= 4;
+	});
+};
+/** Block where the majority of links point to tag/category/related routes. */
+var isTagURLBlock = (el) => {
+	const links = Array.from(el.querySelectorAll("a[href]"));
+	if (links.length < 2) return false;
+	return links.filter((anchor) => CHROME_HREF_PATTERN.test(anchor.getAttribute("href") ?? "")).length / links.length > .6;
+};
+/**
+* True when the element has no body-content descendants. Body content is
+* paragraphs, blockquotes, code/pre, figures, images, and tables — the
+* signal that a block contributes article substance, not chrome. (Lists and
+* raw `<a>` tags don't count: tag clouds and link rails are entirely those.)
+*/
+var hasNoBodyContent = (el) => el.querySelector("p, blockquote, pre, code, figure, img, table") == null;
+var isChromeElement = (el) => {
+	const tag = el.tagName;
+	if (tag === "ASIDE" || tag === "NAV" || tag === "FOOTER") return true;
+	const role = el.getAttribute("role");
+	if (role === "navigation" || role === "complementary" || role === "contentinfo") return true;
+	if (isLinkOnlyList(el)) return true;
+	if (!hasNoBodyContent(el)) return false;
+	if (isTagURLBlock(el)) return true;
+	const classNameAndId = `${(el.getAttribute("class") ?? "").toString()} ${el.id ?? ""}`;
+	if (CHROME_CLASS_PATTERN.test(classNameAndId)) return true;
+	return false;
+};
+/**
+* Find the element defuddle is most likely to treat as the main content
+* root, so we prune at the same scope it'll later extract. Mirrors the
+* common selector chain article > main > [role=main] > body.
+*/
+var findContentRoot = (doc) => doc.querySelector("article") ?? doc.querySelector("main") ?? doc.querySelector("[role=\"main\"]") ?? doc.body;
+/**
+* First pass: scan all descendants of the content root and remove elements
+* that look like chrome wherever they appear. An element qualifies when:
+*   - its class/id contains a chrome keyword
+*     (`tag`, `topic`, `related`, `comments`, `share`, `widget`, `sidebar`,
+*      `footer`, `recommend`, etc.), AND
+*   - it has no body-content descendants (paragraphs, blockquotes, figures,
+*     tables) — i.e. it's a self-contained widget, not an article wrapper
+*     that happens to share a keyword.
+* Plus elements that are structurally just a list of links (tag clouds,
+* "related" rails) regardless of class.
+*
+* This catches chrome buried alongside body content in real-world layouts
+* (e.g. theregister's `<div class="similar_topics">` and `<div class="comments">`
+* nested as siblings of the article body inside `<div id="article-wrapper">`).
+*/
+var pruneChromeDescendants = (root) => {
+	const candidates = Array.from(root.querySelectorAll("*"));
+	for (const el of candidates) {
+		if (!root.contains(el)) continue;
+		if (isChromeElement(el)) el.remove();
+	}
+};
+/**
+* Second pass: when the descendant scan removed an element that used to sit
+* at the trailing edge of the article, the heading that titled it is now
+* dangling. Strip it.
+*
+* Naturally-trailing headings on legitimate articles (essays ending with
+* `<h2>Conclusion</h2>`) are preserved because we only fire when the
+* original trailing edge was actually severed.
+*/
+var trimDanglingTrailingHeading = (root) => {
+	let cursor = root.lastElementChild;
+	while (cursor && isHeading(cursor) && cursor.nextElementSibling == null) {
+		const previous = cursor.previousElementSibling;
+		cursor.remove();
+		cursor = previous;
+	}
+};
+/** @internal exported for unit testing the chrome-pruning rules in isolation. */
+var pruneTrailingChrome = (doc) => {
+	const root = findContentRoot(doc);
+	if (!root) return;
+	const originalLastChild = root.lastElementChild;
+	pruneChromeDescendants(root);
+	if (originalLastChild && !root.contains(originalLastChild)) trimDanglingTrailingHeading(root);
+};
+var mapResult = (result) => {
+	const lead = result.image || void 0;
+	return {
+		markdown: result.contentMarkdown ?? "",
+		html: result.content ?? "",
+		title: result.title || void 0,
+		author: result.author || void 0,
+		description: result.description || void 0,
+		published: result.published || void 0,
+		image: lead,
+		domain: result.domain || void 0,
+		imageUrls: collectImageUrls(lead, result.content ?? ""),
+		wordCount: result.wordCount
+	};
+};
+/**
+* Extracts the main article from a web page's HTML using `defuddle`.
+* Discards navigation, comments, ads, and other chrome; returns the body
+* as Markdown plus structured metadata.
+*
+* Works in both browser/worker (uses `DOMParser`) and Node (delegates to
+* `defuddle/node`, which uses linkedom). The Node path is loaded lazily so
+* the linkedom dependency stays out of browser bundles.
+*/
+var extractArticle = async (html, url) => {
+	if (!html) return {
+		markdown: "",
+		html: "",
+		imageUrls: []
+	};
+	if (isDocumentParserAvailable()) {
+		const doc = new DOMParser().parseFromString(html, "text/html");
+		pruneTrailingChrome(doc);
+		return mapResult(new Defuddle(doc, {
+			url,
+			separateMarkdown: true
+		}).parse());
+	}
+	const { Defuddle: DefuddleNode } = await import("defuddle/node");
+	return mapResult(await DefuddleNode(html, url, { separateMarkdown: true }));
+};
+//#endregion
+//#region src/operations/sources/cors.ts
+/**
+* Cross-origin fetch helpers. Feed/article URLs are arbitrary third-party origins, so in the browser
+* they must be routed through the dev/edge RSS proxy; server-side (no `window`) they're fetched
+* directly.
+*/
+/** Browser proxy path; the target URL is appended URL-encoded. */
+var CORS_PROXY = "/api/rss?url=";
+/** The proxy to use in the current environment: the browser proxy, or undefined server-side. */
+var browserCorsProxy = () => typeof window !== "undefined" ? CORS_PROXY : void 0;
+/** Wraps `url` with `proxy` (URL-encoded) when a proxy is set, else returns `url` unchanged. */
+var applyCorsProxy = (url, proxy) => proxy ? `${proxy}${encodeURIComponent(url)}` : url;
+//#endregion
+//#region src/operations/sources/article.ts
+var FETCH_TIMEOUT_MS = 1e4;
+var MAX_RESPONSE_BYTES = 2e6;
+var MAX_RESPONSE_BYTES_HEADER = 5e6;
+/**
+* Exact-match hostname denylist. Defense-in-depth against trivial SSRF when
+* this runs in a trusted/worker context. Not a substitute for DNS-level
+* egress filtering when available.
+*/
+var BLOCKED_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"0.0.0.0",
+	"::1",
+	"169.254.169.254",
+	"metadata.google.internal"
+]);
+/** Throws unless `link` is an http(s) URL targeting a non-loopback, non-metadata host. */
+var validateUrl = (link) => {
+	const url = new URL(link);
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`Unsupported protocol: ${url.protocol}`);
+	const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+	if (BLOCKED_HOSTS.has(host)) throw new Error(`Blocked host: ${host}`);
+	return url;
+};
+/**
+* Read the body with a hard byte cap; prevents unbounded memory use on
+* adversarial responses. Throws if the stream API is unavailable so we never
+* silently bypass the cap.
+*/
+var readCapped = async (response, limit) => {
+	const reader = response.body?.getReader();
+	if (!reader) throw new Error("Response body stream unavailable.");
+	const decoder = new TextDecoder("utf-8");
+	let received = 0;
+	let out = "";
+	while (received < limit) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		if (value) {
+			received += value.byteLength;
+			out += decoder.decode(value, { stream: true });
+		}
+	}
+	try {
+		await reader.cancel();
+	} catch {}
+	return (out + decoder.decode()).slice(0, limit);
+};
+/**
+* Fetches a post's article page over HTTP and returns extracted plain text
+* plus any image URLs found. Applies protocol validation, a fetch timeout,
+* a Content-Length rejection, and a streamed byte cap.
+*
+* Wraps the original error as `cause` so callers can distinguish
+* AbortError (timeout) from network/fetch failures.
+*/
+var fetchArticle = async (link, options = {}) => {
+	try {
+		const url = validateUrl(link);
+		const fetchTarget = applyCorsProxy(url.toString(), options.corsProxy);
+		const response = await fetch(fetchTarget, {
+			signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+			redirect: "follow"
+		});
+		if (!response.ok) throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
+		const contentLength = response.headers.get("content-length");
+		if (contentLength && Number(contentLength) > MAX_RESPONSE_BYTES_HEADER) throw new Error(`Response too large: ${contentLength} bytes`);
+		const article = await extractArticle(await readCapped(response, MAX_RESPONSE_BYTES), url.toString());
+		return {
+			text: article.markdown,
+			imageUrls: article.imageUrls
+		};
+	} catch (error) {
+		throw new Error(`Failed to fetch article: ${String(error)}`, { cause: error instanceof Error ? error : void 0 });
+	}
+};
+//#endregion
+//#region src/operations/sources/feed-fetcher.ts
+/** Failure fetching or decoding a feed (network error, non-2xx response, or malformed body). */
+var FeedFetchError = class extends Data.TaggedError("FeedFetchError") {};
+//#endregion
+//#region src/operations/sources/http.ts
+var retryPolicy = Schedule.exponential("500 millis").pipe(Schedule.compose(Schedule.recurs(2)));
+/** GETs a URL (through the optional CORS proxy) and decodes the JSON body against `schema`. */
+var getJson = (schema, url, proxy) => HttpClientRequest.get(applyCorsProxy(url, proxy)).pipe(HttpClient.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)), Effect.timeout("10 seconds"), Effect.retry(retryPolicy), Effect.scoped, Effect.mapError((cause) => new FeedFetchError({
+	message: `Fetch failed: ${url}`,
+	cause
+})));
+/** GETs a URL (through the optional CORS proxy) and returns the response body as text. */
+var getText = (url, proxy) => HttpClientRequest.get(applyCorsProxy(url, proxy)).pipe(HttpClient.execute, Effect.flatMap((response) => response.text), Effect.timeout("10 seconds"), Effect.retry(retryPolicy), Effect.scoped, Effect.mapError((cause) => new FeedFetchError({
+	message: `Fetch failed: ${url}`,
+	cause
+})));
+//#endregion
+//#region src/operations/sources/rss.ts
+/**
+* Unwrap `<![CDATA[ ... ]]>` sections, returning the inner content.
+* fast-xml-parser returns stopNode'd content (description / summary / content / content:encoded)
+* verbatim, so CDATA-wrapped HTML — which feeds use pervasively — arrives as a literal
+* `<![CDATA[ ... ]]>` string. Strip the wrapper(s) so the inner HTML reaches downstream
+* conversion. A no-op for values that contain no CDATA section.
+*/
+var stripCdata = (value) => value.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1");
+/**
+* Normalize a fast-xml-parser value to a plain string.
+* fast-xml-parser yields objects like `{'#text': 'foo', '@_type': 'html'}` for
+* elements with attributes, and plain strings/numbers for text-only elements.
+* Returns undefined for nullish values.
+*
+* Entities are decoded explicitly: stopNode'd nodes (description / content /
+* summary / content:encoded) are returned as raw text by fast-xml-parser,
+* skipping its built-in entity decoding and CDATA unwrapping. Decoding and
+* CDATA stripping here keep callers from having to special-case those fields.
+* For non-stopped nodes both are no-ops (the parser has already decoded
+* entities and there is no CDATA wrapper).
+*/
+var text = (value) => {
+	if (value == null) return;
+	if (typeof value === "string") return decodeEntities(stripCdata(value));
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (typeof value === "object") {
+		const t = value["#text"];
+		if (typeof t === "string") return decodeEntities(stripCdata(t));
+		if (typeof t === "number" || typeof t === "boolean") return String(t);
+	}
+};
+/**
+* Convert a feed text value to Markdown. Feed description/content/summary fields routinely carry
+* embedded HTML (escaped or raw); normalizeText converts it to Markdown and passes plaintext
+* through unchanged. Returns undefined for nullish values.
+*/
+var markdown = (value) => value != null ? normalizeText(value) : void 0;
+/** Fetches and parses an RSS/Atom feed URL into Subscription objects. */
+var fetchRss = (url, options) => Effect.gen(function* () {
+	const xml = yield* getText(url, options?.corsProxy);
+	return yield* Effect.try({
+		try: () => parseFeed(url, xml),
+		catch: (cause) => new FeedFetchError({
+			message: `Unrecognized feed format: ${url}`,
+			cause
+		})
+	});
+}).pipe(Effect.provide(FetchHttpClient.layer));
+/** Parses RSS/Atom XML into a normalized {@link FetchResult}; throws on an unrecognized shape. */
+var parseFeed = (url, xml) => {
+	const parsed = new XMLParser({
+		ignoreAttributes: false,
+		attributeNamePrefix: "@_",
+		maxNestedTags: 1e4,
+		stopNodes: [
+			"*.description",
+			"*.summary",
+			"*.content",
+			"*.content:encoded"
+		]
+	}).parse(xml);
+	const channel = parsed.rss?.channel ?? parsed.feed;
+	if (!channel) throw new Error("Unrecognized feed format");
+	const isAtom = !parsed.rss;
+	const feedName = text(channel.title) ?? "";
+	const feedDescription = markdown(text(isAtom ? channel.subtitle : channel.description)) ?? "";
+	const items = (isAtom ? channel.entry : channel.item) ?? [];
+	const posts = (Array.isArray(items) ? items : [items]).map((item) => {
+		const link = isAtom ? (Array.isArray(item.link) ? item.link.find((l) => l["@_rel"] === "alternate")?.["@_href"] : item.link?.["@_href"] ?? text(item.link)) ?? "" : text(item.link) ?? "";
+		const author = isAtom ? text(item.author?.name) ?? text(item.author) : text(item["dc:creator"]) ?? text(item.author);
+		const description = markdown(text(item.description));
+		const content = isAtom ? markdown(text(item.summary)) ?? markdown(text(item.content)) : markdown(text(item["content:encoded"]));
+		return Subscription.makePost({
+			title: text(item.title),
+			link,
+			description,
+			content,
+			author,
+			published: text(item.pubDate) ?? text(item.published) ?? text(item.updated),
+			guid: (isAtom ? text(item.id) : text(item.guid)) ?? link
+		});
+	});
+	return {
+		feed: Subscription.makeSubscription({
+			name: feedName,
+			url,
+			description: feedDescription
+		}),
+		posts
+	};
+};
+//#endregion
+//#region src/operations/sources/standard-site.ts
+var BSKY_PUBLIC_API = "https://public.api.bsky.app/xrpc";
+var PLC_DIRECTORY = "https://plc.directory";
+var DOCUMENT_COLLECTION = "site.standard.document";
+var MARKDOWN_CONTENT_TYPE = "site.standard.content.markdown";
+/** URL builders for the AT Protocol XRPC endpoints used by this module. */
+var endpoints = {
+	resolveHandle: (handle) => `${BSKY_PUBLIC_API}/com.atproto.identity.resolveHandle?handle=${encodeURIComponent(handle)}`,
+	getProfile: (actor) => `${BSKY_PUBLIC_API}/app.bsky.actor.getProfile?actor=${encodeURIComponent(actor)}`,
+	searchActors: (query, limit) => `${BSKY_PUBLIC_API}/app.bsky.actor.searchActorsTypeahead?q=${encodeURIComponent(query)}&limit=${limit}`,
+	plcDoc: (did) => `${PLC_DIRECTORY}/${did}`,
+	listRecords: (pds, did, collection, limit) => `${pds}/xrpc/com.atproto.repo.listRecords?repo=${encodeURIComponent(did)}&collection=${encodeURIComponent(collection)}&limit=${limit}`,
+	getRecord: (pds, did, collection, rkey) => `${pds}/xrpc/com.atproto.repo.getRecord?repo=${encodeURIComponent(did)}&collection=${encodeURIComponent(collection)}&rkey=${encodeURIComponent(rkey)}`
+};
+/**
+* Extracts an atproto handle or DID from a URL or raw identifier.
+* Supports: bare handles (`dxos.org`), `@handle`, `did:plc:…`/`did:web:…`, or a
+* `https://bsky.app/profile/{actor}` URL.
+*/
+var parseStandardSiteActor = (url) => {
+	const match = url.match(/bsky\.app\/profile\/([^/?#]+)/);
+	if (match) return match[1];
+	return url.replace(/^@/, "").trim();
+};
+/** Lists the publications a handle publishes under (deduped by `site`), for publication selection. */
+var listStandardSitePublications = (actorOrUrl, options) => Effect.gen(function* () {
+	const proxy = options?.corsProxy;
+	const did = yield* resolveDid(parseStandardSiteActor(actorOrUrl), proxy);
+	const sites = distinct((yield* listDocuments(yield* resolvePds(did, proxy), did, proxy)).map((record) => record.value.site).filter(isString));
+	return yield* Effect.forEach(sites, (site) => resolvePublication(site, proxy).pipe(Effect.catchAll(() => Effect.succeed({ site }))), { concurrency: "unbounded" });
+}).pipe(Effect.provide(FetchHttpClient.layer));
+/** Searches atproto handles by prefix (typeahead), for combobox suggestions; empty on blank/failed query. */
+var searchStandardSiteHandles = (query, options) => query.trim().length === 0 ? Effect.succeed([]) : getJson(SearchActorsResponse, endpoints.searchActors(query.trim(), 8), options?.corsProxy).pipe(Effect.map((response) => (response.actors ?? []).map((actor) => ({
+	handle: actor.handle,
+	displayName: actor.displayName
+}))), Effect.orElseSucceed(() => []), Effect.provide(FetchHttpClient.layer));
+/**
+* Fetches a Standard.site feed. `url` is the publication's `site` reference — either an `at://` URI
+* (DID extracted directly) or an `https://` URL (DID resolved via `/.well-known/atproto-did`). In both
+* cases, all documents in the author's repo filtered to that publication are fetched.
+*/
+var fetchStandardSite = (url, options) => Effect.gen(function* () {
+	const proxy = options?.corsProxy;
+	const did = yield* resolveDidFromSite(url, proxy);
+	const records = (yield* listDocuments(yield* resolvePds(did, proxy), did, proxy)).filter((record) => record.value.site === url);
+	const profile = yield* fetchProfile(did, proxy);
+	const authorName = profile?.displayName ?? profile?.handle ?? did;
+	const publication = yield* resolvePublication(url, proxy).pipe(Effect.catchAll(() => Effect.succeed({ site: url })));
+	const posts = records.map((record) => {
+		const value = record.value;
+		const content = value.content?.$type === MARKDOWN_CONTENT_TYPE ? value.content.text : void 0;
+		const description = value.description ?? (value.textContent ? makeSnippet(value.textContent) : void 0);
+		return Subscription.makePost({
+			title: value.title,
+			link: joinUrl(publication.url, value.path),
+			description,
+			content,
+			author: authorName,
+			published: value.publishedAt,
+			guid: record.uri
+		});
+	});
+	posts.sort((postA, postB) => (postB.published ?? "").localeCompare(postA.published ?? ""));
+	return {
+		feed: Subscription.makeSubscription({
+			name: publication.name ?? authorName,
+			url,
+			description: profile?.description ?? `Standard.site articles from @${profile?.handle ?? did}`,
+			iconUrl: profile?.avatar,
+			type: "standard-site"
+		}),
+		posts
+	};
+}).pipe(Effect.provide(FetchHttpClient.layer));
+var ResolveHandleResponse = Schema.Struct({ did: Schema.optional(Schema.String) });
+var SearchActorsResponse = Schema.Struct({ actors: Schema.optional(Schema.Array(Schema.Struct({
+	handle: Schema.String,
+	displayName: Schema.optional(Schema.String)
+}))) });
+var DidDocument = Schema.Struct({ service: Schema.optional(Schema.Array(Schema.Struct({
+	id: Schema.optional(Schema.String),
+	type: Schema.optional(Schema.String),
+	serviceEndpoint: Schema.optional(Schema.String)
+}))) });
+var Profile = Schema.Struct({
+	handle: Schema.optional(Schema.String),
+	displayName: Schema.optional(Schema.String),
+	avatar: Schema.optional(Schema.String),
+	description: Schema.optional(Schema.String)
+});
+var StandardSiteDocument = Schema.Struct({
+	site: Schema.optional(Schema.String),
+	title: Schema.optional(Schema.String),
+	publishedAt: Schema.optional(Schema.String),
+	path: Schema.optional(Schema.String),
+	description: Schema.optional(Schema.String),
+	content: Schema.optional(Schema.Struct({
+		$type: Schema.optional(Schema.String),
+		text: Schema.optional(Schema.String)
+	})),
+	textContent: Schema.optional(Schema.String)
+});
+var ListRecordsResponse = Schema.Struct({
+	records: Schema.optional(Schema.Array(Schema.Struct({
+		uri: Schema.String,
+		value: StandardSiteDocument
+	}))),
+	cursor: Schema.optional(Schema.String)
+});
+var PublicationRecord = Schema.Struct({ value: Schema.optional(Schema.Struct({
+	url: Schema.optional(Schema.String),
+	name: Schema.optional(Schema.String)
+})) });
+/**
+* Resolves a publication `site` reference to its author's DID:
+* - `at://did:…/…` → DID extracted directly from the URI.
+* - `https://…` → DID fetched from `/.well-known/atproto-did` on that domain.
+*/
+var resolveDidFromSite = (site, proxy) => {
+	if (site.startsWith("at://")) {
+		const parsed = parseAtUri(site);
+		return parsed ? Effect.succeed(parsed.did) : Effect.fail(new FeedFetchError({ message: `Malformed at:// site reference: ${site}` }));
+	}
+	if (site.startsWith("https://")) {
+		const { hostname } = new URL(site);
+		return getJson(Schema.Struct({ did: Schema.optional(Schema.String) }), `https://${hostname}/.well-known/atproto-did`, proxy).pipe(Effect.flatMap((result) => result.did ? Effect.succeed(result.did) : Effect.fail(new FeedFetchError({ message: `No atproto DID found at ${hostname}/.well-known/atproto-did` }))));
+	}
+	return Effect.fail(new FeedFetchError({ message: `Cannot resolve DID from site reference: ${site}` }));
+};
+/** Resolves a handle to a DID (no-op when already a DID) via the public `resolveHandle` XRPC. */
+var resolveDid = (actor, proxy) => actor.startsWith("did:") ? Effect.succeed(actor) : getJson(ResolveHandleResponse, endpoints.resolveHandle(actor), proxy).pipe(Effect.flatMap((resolved) => resolved.did ? Effect.succeed(resolved.did) : Effect.fail(new FeedFetchError({ message: `Could not resolve handle to DID: ${actor}` }))));
+/**
+* Resolves a DID to its PDS endpoint: `did:plc` via the PLC directory DID-doc, `did:web` via the
+* domain's `/.well-known/did.json`. Mirrors `plugin-bluesky`'s `BlueskyApi.resolvePds` endpoints.
+*/
+var resolvePds = (did, proxy) => {
+	if (did.startsWith("did:plc:")) return getJson(DidDocument, endpoints.plcDoc(did), proxy).pipe(Effect.flatMap((doc) => extractPds(doc, did)));
+	if (did.startsWith("did:web:")) {
+		const [host, ...segments] = did.slice(8).split(":").map((segment) => decodeURIComponent(segment));
+		if (!host) return Effect.fail(new FeedFetchError({ message: `Invalid did:web identifier: ${did}` }));
+		return getJson(DidDocument, `https://${host}${segments.length > 0 ? `/${segments.join("/")}/did.json` : "/.well-known/did.json"}`, proxy).pipe(Effect.flatMap((doc) => extractPds(doc, did)));
+	}
+	return Effect.fail(new FeedFetchError({ message: `Unsupported DID method: ${did}` }));
+};
+var extractPds = (doc, did) => {
+	const endpoint = (doc.service?.find((entry) => entry.id === "#atproto_pds" || entry.type === "AtprotoPersonalDataServer"))?.serviceEndpoint;
+	return typeof endpoint === "string" && endpoint.length > 0 ? Effect.succeed(endpoint.replace(/\/$/, "")) : Effect.fail(new FeedFetchError({ message: `No PDS endpoint found for DID: ${did}` }));
+};
+/** Lists ALL of the actor's `site.standard.document` records by following pagination cursors. */
+var listDocuments = (pds, did, proxy) => Effect.gen(function* () {
+	const all = [];
+	let cursor;
+	do {
+		const page = yield* getJson(ListRecordsResponse, endpoints.listRecords(pds, did, DOCUMENT_COLLECTION, 100) + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""), proxy);
+		all.push(...page.records ?? []);
+		cursor = page.cursor;
+	} while (cursor);
+	return all;
+});
+/** Best-effort author profile lookup (display name / avatar / bio); undefined on any failure. */
+var fetchProfile = (actor, proxy) => getJson(Profile, endpoints.getProfile(actor), proxy).pipe(Effect.catchAll(() => Effect.succeed(void 0)));
+/**
+* Resolves a publication `site` reference to its {@link Publication} metadata:
+* - `https://` → canonical URL directly (no record fetch needed).
+* - `at://` → `getRecord` the publication record for `url`/`name`.
+*/
+var resolvePublication = (site, proxy) => {
+	if (site.startsWith("http")) return Effect.succeed({
+		site,
+		url: site.replace(/\/$/, "")
+	});
+	if (site.startsWith("at://")) {
+		const parsed = parseAtUri(site);
+		if (!parsed) return Effect.succeed({ site });
+		return Effect.gen(function* () {
+			const pds = yield* resolvePds(parsed.did, proxy);
+			const value = (yield* getJson(PublicationRecord, endpoints.getRecord(pds, parsed.did, parsed.collection, parsed.rkey), proxy)).value ?? {};
+			return {
+				site,
+				url: value.url ? value.url.replace(/\/$/, "") : void 0,
+				name: value.name
+			};
+		});
+	}
+	return Effect.succeed({ site });
+};
+/** Splits an `at://{did}/{collection}/{rkey}` URI into its parts; undefined when malformed. */
+var parseAtUri = (uri) => {
+	const match = uri.match(/^at:\/\/([^/]+)\/([^/]+)\/([^/]+)$/);
+	return match ? {
+		did: match[1],
+		collection: match[2],
+		rkey: match[3]
+	} : void 0;
+};
+/** Joins a publication base URL with a document path into a canonical link. */
+var joinUrl = (base, path) => {
+	if (!base) return;
+	if (!path) return base;
+	return `${base}${path.startsWith("/") ? "" : "/"}${path}`;
+};
+var isString = (value) => typeof value === "string";
+var distinct = (values) => [...new Set(values)];
+//#endregion
+export { fetchArticle as a, fetchRss as i, listStandardSitePublications as n, browserCorsProxy as o, searchStandardSiteHandles as r, fetchStandardSite as t };
+
+//# sourceMappingURL=chunk-sources.mjs.map