@atproto-ui/core 0.13.0

package/dist/backlinks.d.ts

@@ -0,0 +1,18 @@
+export interface BacklinkRecord {
+    did: string;
+    collection: string;
+    rkey: string;
+}
+export interface BacklinksResponse {
+    total: number;
+    records: BacklinkRecord[];
+    cursor?: string;
+}
+export interface FetchBacklinksOptions {
+    subject: string;
+    source: string;
+    limit?: number;
+    constellationBaseUrl?: string;
+    signal?: AbortSignal;
+}
+export declare function fetchBacklinks({ subject, source, limit, constellationBaseUrl, signal, }: FetchBacklinksOptions): Promise<BacklinksResponse>;

package/dist/backlinks.js

@@ -0,0 +1,15 @@
+async function fetchBacklinks({ subject: e, source: t, limit: n = 16, constellationBaseUrl: r = "https://constellation.microcosm.blue", signal: i }) {
+	let a = r.endsWith("/") ? r.slice(0, -1) : r, o = new URLSearchParams({
+		subject: e,
+		source: t,
+		limit: String(n)
+	}), s = await fetch(`${a}/xrpc/blue.microcosm.links.getBacklinks?${o}`, { signal: i });
+	if (!s.ok) throw Error(`Failed to fetch backlinks: ${s.status} ${s.statusText}`);
+	let c = await s.json();
+	return {
+		total: c.total ?? 0,
+		records: c.records ?? [],
+		cursor: c.cursor
+	};
+}
+export { fetchBacklinks };

package/dist/blob-fetch.d.ts

@@ -0,0 +1,42 @@
+import type { BlobCache } from "./cache";
+import type { ServiceResolver } from "./client";
+export interface GetBlobOptions {
+    blobCache: BlobCache;
+    resolver: ServiceResolver;
+    handleOrDid: string;
+    blob: unknown;
+    /**
+     * When false, ignore appview CDN URLs and always fetch the blob from the PDS.
+     * Defaults to true so banned/unavailable appview accounts still resolve via PDS.
+     */
+    preferCdn?: boolean;
+}
+/**
+ * Resolves a renderable image URL for a blob.
+ *
+ * - When the blob carries an appview CDN URL, that URL is returned directly. CDN
+ *   URLs are CORS-safe as an `<img src>` but NOT fetchable, so we never `fetch()`
+ *   them — they are handed back verbatim and `release()` is a no-op.
+ * - Otherwise the blob is fetched from the owner's PDS via
+ *   `com.atproto.sync.getBlob`, cached, and exposed as an object URL that
+ *   `release()` revokes.
+ *
+ * The caller only renders `url`; identity/PDS/CDN orchestration stays here.
+ */
+export declare function getBlob(options: GetBlobOptions): {
+    promise: Promise<string>;
+    release: () => void;
+};
+/**
+ * Low-level PDS blob fetch when the DID and PDS endpoint are already known.
+ * Returns the raw {@link Blob}; callers manage object URLs themselves.
+ */
+export declare function fetchBlob(options: {
+    blobCache: BlobCache;
+    did: string;
+    cid: string;
+    endpoint: string;
+}): {
+    promise: Promise<Blob>;
+    release: () => void;
+};

package/dist/blob-fetch.js

@@ -0,0 +1,53 @@
+import { extractCidFromBlob, getBlobImageUrl } from "./utils/blob.js";
+function getBlob(n) {
+	let r = n.preferCdn === !1 ? void 0 : getBlobImageUrl(n.blob);
+	if (r) return {
+		promise: Promise.resolve(r),
+		release: () => {}
+	};
+	let a = n.handleOrDid.trim(), o = extractCidFromBlob(n.blob);
+	if (!a) return failed(/* @__PURE__ */ Error("handleOrDid is required"));
+	if (!o) return failed(/* @__PURE__ */ Error("Blob CID is required"));
+	let s, c;
+	return {
+		promise: (async () => {
+			let e = a.startsWith("did:") ? a : await n.resolver.resolveHandle(a), t = await n.resolver.pdsEndpointForDid(e), r = n.blobCache.ensure(e, o, () => {
+				let n = new AbortController();
+				return {
+					promise: (async () => {
+						let r = await fetch(`${t}/xrpc/com.atproto.sync.getBlob?did=${encodeURIComponent(e)}&cid=${encodeURIComponent(o)}`, { signal: n.signal });
+						if (!r.ok) throw Error(`Blob fetch failed (${r.status})`);
+						return r.blob();
+					})(),
+					abort: () => n.abort()
+				};
+			});
+			c = r.release;
+			let i = await r.promise;
+			return s = URL.createObjectURL(i), s;
+		})(),
+		release: () => {
+			s &&= (URL.revokeObjectURL(s), void 0), c?.();
+		}
+	};
+}
+function fetchBlob(e) {
+	return e.blobCache.ensure(e.did, e.cid, () => {
+		let t = new AbortController();
+		return {
+			promise: (async () => {
+				let n = await fetch(`${e.endpoint}/xrpc/com.atproto.sync.getBlob?did=${encodeURIComponent(e.did)}&cid=${encodeURIComponent(e.cid)}`, { signal: t.signal });
+				if (!n.ok) throw Error(`Blob fetch failed (${n.status})`);
+				return n.blob();
+			})(),
+			abort: () => t.abort()
+		};
+	});
+}
+function failed(e) {
+	return {
+		promise: Promise.reject(e),
+		release: () => {}
+	};
+}
+export { fetchBlob, getBlob };

package/dist/cache.d.ts

@@ -0,0 +1,155 @@
+import type { DidDocument } from "@atcute/identity";
+import { ServiceResolver } from "./client";
+export interface DidCacheStats {
+    entriesByDid: number;
+    entriesByHandle: number;
+    inFlightHandles: number;
+    inFlightDocs: number;
+    inFlightPdsEndpoints: number;
+    handleLookupHits: number;
+    handleLookupMisses: number;
+    didLookupHits: number;
+    didLookupMisses: number;
+    handleCacheHits: number;
+    handleFetches: number;
+    handleJoins: number;
+    docCacheHits: number;
+    docFetches: number;
+    docJoins: number;
+    pdsCacheHits: number;
+    pdsFetches: number;
+    pdsJoins: number;
+    writes: number;
+    stableSnapshotReuses: number;
+}
+export interface DidCacheSnapshot {
+    did?: string;
+    handle?: string;
+    doc?: DidDocument;
+    pdsEndpoint?: string;
+}
+export declare class DidCache {
+    private byHandle;
+    private byDid;
+    private handlePromises;
+    private docPromises;
+    private pdsPromises;
+    private statsData;
+    getByHandle(handle: string | undefined): DidCacheSnapshot | undefined;
+    getByDid(did: string | undefined): DidCacheSnapshot | undefined;
+    memoize(entry: {
+        did: string;
+        handle?: string;
+        doc?: DidDocument;
+        pdsEndpoint?: string;
+    }): DidCacheSnapshot;
+    ensureHandle(resolver: ServiceResolver, handle: string): Promise<DidCacheSnapshot>;
+    ensureDidDoc(resolver: ServiceResolver, did: string): Promise<DidCacheSnapshot>;
+    ensurePdsEndpoint(resolver: ServiceResolver, did: string): Promise<DidCacheSnapshot>;
+    stats(): DidCacheStats;
+    resetStats(): void;
+    clear(): void;
+}
+interface EnsureResult {
+    promise: Promise<Blob>;
+    release: () => void;
+}
+export interface CacheBucketStats {
+    entries: number;
+    inFlight: number;
+    hits: number;
+    misses: number;
+    sets: number;
+    inFlightStarts: number;
+    inFlightJoins: number;
+    releases: number;
+    skipped?: number;
+}
+export declare class BlobCache {
+    private store;
+    private inFlight;
+    private statsData;
+    private key;
+    get(did?: string, cid?: string): Blob | undefined;
+    set(did: string, cid: string, blob: Blob): void;
+    ensure(did: string, cid: string, loader: () => {
+        promise: Promise<Blob>;
+        abort: () => void;
+    }): EnsureResult;
+    private release;
+    stats(): CacheBucketStats;
+    resetStats(): void;
+    clear(): void;
+}
+interface RecordEnsureResult<T = unknown> {
+    promise: Promise<T>;
+    release: () => void;
+}
+export declare class RecordCache {
+    private store;
+    private inFlight;
+    private statsData;
+    private noCacheCollections;
+    private key;
+    private shouldCache;
+    get<T = unknown>(did?: string, collection?: string, rkey?: string): T | undefined;
+    set<T = unknown>(did: string, collection: string, rkey: string, record: T): void;
+    ensure<T = unknown>(did: string, collection: string, rkey: string, loader: () => {
+        promise: Promise<T>;
+        abort: () => void;
+    }): RecordEnsureResult<T>;
+    private release;
+    stats(): CacheBucketStats;
+    resetStats(): void;
+    clear(): void;
+}
+interface PageEnsureResult<T = unknown> {
+    promise: Promise<T>;
+    release: () => void;
+}
+export declare class PaginatedRecordsCache {
+    private store;
+    private inFlight;
+    private statsData;
+    get<T = unknown>(key: string | undefined): T | undefined;
+    set<T = unknown>(key: string, page: T): void;
+    ensure<T = unknown>(key: string, loader: () => Promise<T>): PageEnsureResult<T>;
+    private release;
+    stats(): CacheBucketStats;
+    resetStats(): void;
+    clear(): void;
+}
+/**
+ * Library-owned cache singletons.
+ *
+ * Caches are config-free and keyed by universal identifiers (DID, CID, at-uri),
+ * so they are shared across the entire app and—critically—survive component and
+ * provider remounts. Cache lifetime must NOT be tied to component lifecycle; a
+ * remounting provider should reuse these, not recreate them, or in-flight and
+ * cached data is lost on every remount.
+ */
+export interface AtprotoCaches {
+    didCache: DidCache;
+    blobCache: BlobCache;
+    recordCache: RecordCache;
+    paginatedRecordsCache: PaginatedRecordsCache;
+}
+export interface AtprotoCacheStats {
+    did: DidCacheStats;
+    blob: CacheBucketStats;
+    record: CacheBucketStats;
+    paginatedRecords: CacheBucketStats;
+}
+export declare const sharedDidCache: DidCache;
+export declare const sharedBlobCache: BlobCache;
+export declare const sharedRecordCache: RecordCache;
+export declare const sharedPaginatedRecordsCache: PaginatedRecordsCache;
+/** Returns the shared, library-owned cache instances. */
+export declare function getSharedCaches(): AtprotoCaches;
+/** Returns point-in-time counters and sizes for the shared cache singletons. */
+export declare function getSharedCacheStats(): AtprotoCacheStats;
+/** Resets counters only. Cached entries remain available for warm-run benchmarks. */
+export declare function resetSharedCacheStats(): void;
+/** Clears entries and in-flight maps from the shared cache singletons. */
+export declare function clearSharedCaches(): void;
+export {};

package/dist/cache.js

@@ -0,0 +1,345 @@
+var createDidStats = () => ({
+	handleLookupHits: 0,
+	handleLookupMisses: 0,
+	didLookupHits: 0,
+	didLookupMisses: 0,
+	handleCacheHits: 0,
+	handleFetches: 0,
+	handleJoins: 0,
+	docCacheHits: 0,
+	docFetches: 0,
+	docJoins: 0,
+	pdsCacheHits: 0,
+	pdsFetches: 0,
+	pdsJoins: 0,
+	writes: 0,
+	stableSnapshotReuses: 0
+}), toSnapshot = (e) => {
+	if (!e) return;
+	if (e.snapshot) return e.snapshot;
+	let { did: o, handle: s, doc: c, pdsEndpoint: l } = e, u = {
+		did: o,
+		handle: s,
+		doc: c,
+		pdsEndpoint: l
+	};
+	return e.snapshot = u, u;
+}, derivePdsEndpoint = (e) => {
+	if (!e?.service) return;
+	let o = e.service.find((e) => e.type === "AtprotoPersonalDataServer");
+	if (!o) return;
+	let s = typeof o.serviceEndpoint == "string" ? o.serviceEndpoint : void 0;
+	if (s) return s.replace(/\/$/, "");
+}, DidCache = class {
+	constructor() {
+		this.byHandle = /* @__PURE__ */ new Map(), this.byDid = /* @__PURE__ */ new Map(), this.handlePromises = /* @__PURE__ */ new Map(), this.docPromises = /* @__PURE__ */ new Map(), this.pdsPromises = /* @__PURE__ */ new Map(), this.statsData = createDidStats();
+	}
+	getByHandle(e) {
+		if (!e) return;
+		let s = this.byHandle.get(e.toLowerCase());
+		return s ? this.statsData.handleLookupHits += 1 : this.statsData.handleLookupMisses += 1, toSnapshot(s);
+	}
+	getByDid(e) {
+		if (!e) return;
+		let s = this.byDid.get(e);
+		return s ? this.statsData.didLookupHits += 1 : this.statsData.didLookupMisses += 1, toSnapshot(s);
+	}
+	memoize(e) {
+		let c = e.did, l = e.handle?.toLowerCase(), u = this.byDid.get(c) ?? (l ? this.byHandle.get(l) : void 0), d = e.doc ?? u?.doc, f = l ?? u?.handle, p = e.pdsEndpoint ?? derivePdsEndpoint(d) ?? u?.pdsEndpoint;
+		if (u && u.did === c && u.handle === f && u.doc === d && u.pdsEndpoint === p) return this.statsData.stableSnapshotReuses += 1, toSnapshot(u);
+		let m = {
+			did: c,
+			handle: f,
+			doc: d,
+			pdsEndpoint: p,
+			timestamp: Date.now(),
+			snapshot: void 0
+		};
+		return this.byDid.set(c, m), f && this.byHandle.set(f, m), this.statsData.writes += 1, toSnapshot(m);
+	}
+	ensureHandle(e, o) {
+		let s = o.toLowerCase(), c = this.getByHandle(s);
+		if (c?.did) return this.statsData.handleCacheHits += 1, Promise.resolve(c);
+		let l = this.handlePromises.get(s);
+		if (l) return this.statsData.handleJoins += 1, l;
+		this.statsData.handleFetches += 1;
+		let u = e.resolveHandle(s).then((e) => this.memoize({
+			did: e,
+			handle: s
+		})).finally(() => {
+			this.handlePromises.delete(s);
+		});
+		return this.handlePromises.set(s, u), u;
+	}
+	ensureDidDoc(e, o) {
+		let s = this.getByDid(o);
+		if (s?.doc) return this.statsData.docCacheHits += 1, Promise.resolve(s);
+		let c = this.docPromises.get(o);
+		if (c) return this.statsData.docJoins += 1, c;
+		this.statsData.docFetches += 1;
+		let l = e.resolveDidDoc(o).then((e) => {
+			let c = e.alsoKnownAs?.find((e) => e.startsWith("at://")), l = c ? c.replace("at://", "").toLowerCase() : s?.handle;
+			return this.memoize({
+				did: o,
+				handle: l,
+				doc: e
+			});
+		}).finally(() => {
+			this.docPromises.delete(o);
+		});
+		return this.docPromises.set(o, l), l;
+	}
+	ensurePdsEndpoint(e, o) {
+		let s = this.getByDid(o);
+		if (s?.pdsEndpoint) return this.statsData.pdsCacheHits += 1, Promise.resolve(s);
+		let c = this.pdsPromises.get(o);
+		if (c) return this.statsData.pdsJoins += 1, c;
+		this.statsData.pdsFetches += 1;
+		let l = (async () => {
+			let s = await this.ensureDidDoc(e, o).catch(() => void 0);
+			if (s?.pdsEndpoint) return s;
+			let c = await e.pdsEndpointForDid(o);
+			return this.memoize({
+				did: o,
+				pdsEndpoint: c
+			});
+		})().finally(() => {
+			this.pdsPromises.delete(o);
+		});
+		return this.pdsPromises.set(o, l), l;
+	}
+	stats() {
+		return {
+			...this.statsData,
+			entriesByDid: this.byDid.size,
+			entriesByHandle: this.byHandle.size,
+			inFlightHandles: this.handlePromises.size,
+			inFlightDocs: this.docPromises.size,
+			inFlightPdsEndpoints: this.pdsPromises.size
+		};
+	}
+	resetStats() {
+		this.statsData = createDidStats();
+	}
+	clear() {
+		this.byHandle.clear(), this.byDid.clear(), this.handlePromises.clear(), this.docPromises.clear(), this.pdsPromises.clear();
+	}
+}, createBucketStats = () => ({
+	hits: 0,
+	misses: 0,
+	sets: 0,
+	inFlightStarts: 0,
+	inFlightJoins: 0,
+	releases: 0,
+	skipped: 0
+}), BlobCache = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map(), this.inFlight = /* @__PURE__ */ new Map(), this.statsData = createBucketStats();
+	}
+	key(e, o) {
+		return `${e}::${o}`;
+	}
+	get(e, o) {
+		if (!e || !o) return;
+		let s = this.store.get(this.key(e, o));
+		return s ? this.statsData.hits += 1 : this.statsData.misses += 1, s?.blob;
+	}
+	set(e, o, s) {
+		this.store.set(this.key(e, o), {
+			blob: s,
+			timestamp: Date.now()
+		}), this.statsData.sets += 1;
+	}
+	ensure(e, o, s) {
+		let c = this.get(e, o);
+		if (c) return {
+			promise: Promise.resolve(c),
+			release: () => {}
+		};
+		let l = this.key(e, o), u = this.inFlight.get(l);
+		if (u) return u.refCount += 1, this.statsData.inFlightJoins += 1, {
+			promise: u.promise,
+			release: () => this.release(l)
+		};
+		let { promise: d, abort: f } = s();
+		this.statsData.inFlightStarts += 1;
+		let p = d.then((s) => (this.set(e, o, s), s)), m = {
+			promise: p,
+			abort: f,
+			refCount: 1
+		};
+		return this.inFlight.set(l, m), p.catch(() => {}).finally(() => {
+			this.inFlight.delete(l);
+		}), {
+			promise: p,
+			release: () => this.release(l)
+		};
+	}
+	release(e) {
+		let o = this.inFlight.get(e);
+		o && (--o.refCount, this.statsData.releases += 1);
+	}
+	stats() {
+		return {
+			...this.statsData,
+			entries: this.store.size,
+			inFlight: this.inFlight.size
+		};
+	}
+	resetStats() {
+		this.statsData = createBucketStats();
+	}
+	clear() {
+		this.store.clear(), this.inFlight.clear();
+	}
+}, RecordCache = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map(), this.inFlight = /* @__PURE__ */ new Map(), this.statsData = createBucketStats(), this.noCacheCollections = new Set(["fm.teal.alpha.actor.status", "fm.teal.alpha.feed.play"]);
+	}
+	key(e, o, s) {
+		return `${e}::${o}::${s}`;
+	}
+	shouldCache(e) {
+		return !this.noCacheCollections.has(e);
+	}
+	get(e, o, s) {
+		if (!e || !o || !s) return;
+		if (!this.shouldCache(o)) {
+			this.statsData.skipped = (this.statsData.skipped ?? 0) + 1;
+			return;
+		}
+		let c = this.store.get(this.key(e, o, s));
+		return c ? this.statsData.hits += 1 : this.statsData.misses += 1, c?.record;
+	}
+	set(e, o, s, c) {
+		if (!this.shouldCache(o)) {
+			this.statsData.skipped = (this.statsData.skipped ?? 0) + 1;
+			return;
+		}
+		this.store.set(this.key(e, o, s), {
+			record: c,
+			timestamp: Date.now()
+		}), this.statsData.sets += 1;
+	}
+	ensure(e, o, s, c) {
+		let l = this.get(e, o, s);
+		if (l !== void 0) return {
+			promise: Promise.resolve(l),
+			release: () => {}
+		};
+		let u = this.key(e, o, s), d = this.inFlight.get(u);
+		if (d) return d.refCount += 1, this.statsData.inFlightJoins += 1, {
+			promise: d.promise,
+			release: () => this.release(u)
+		};
+		let { promise: f, abort: p } = c();
+		this.statsData.inFlightStarts += 1;
+		let m = f.then((c) => (this.set(e, o, s, c), c)), h = {
+			promise: m,
+			abort: p,
+			refCount: 1
+		};
+		return this.inFlight.set(u, h), m.catch(() => {}).finally(() => {
+			this.inFlight.delete(u);
+		}), {
+			promise: m,
+			release: () => this.release(u)
+		};
+	}
+	release(e) {
+		let o = this.inFlight.get(e);
+		o && (--o.refCount, this.statsData.releases += 1);
+	}
+	stats() {
+		return {
+			...this.statsData,
+			entries: this.store.size,
+			inFlight: this.inFlight.size
+		};
+	}
+	resetStats() {
+		this.statsData = createBucketStats();
+	}
+	clear() {
+		this.store.clear(), this.inFlight.clear();
+	}
+}, PaginatedRecordsCache = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map(), this.inFlight = /* @__PURE__ */ new Map(), this.statsData = createBucketStats();
+	}
+	get(e) {
+		if (!e) return;
+		let o = this.store.get(e);
+		return o ? this.statsData.hits += 1 : this.statsData.misses += 1, o?.page;
+	}
+	set(e, o) {
+		this.store.set(e, {
+			page: o,
+			timestamp: Date.now()
+		}), this.statsData.sets += 1;
+	}
+	ensure(e, o) {
+		let s = this.get(e);
+		if (s !== void 0) return {
+			promise: Promise.resolve(s),
+			release: () => {}
+		};
+		let c = this.inFlight.get(e);
+		if (c) return c.refCount += 1, this.statsData.inFlightJoins += 1, {
+			promise: c.promise,
+			release: () => this.release(e)
+		};
+		this.statsData.inFlightStarts += 1;
+		let l = o().then((o) => (this.set(e, o), o));
+		return this.inFlight.set(e, {
+			promise: l,
+			refCount: 1
+		}), l.catch(() => {}).finally(() => {
+			this.inFlight.delete(e);
+		}), {
+			promise: l,
+			release: () => this.release(e)
+		};
+	}
+	release(e) {
+		let o = this.inFlight.get(e);
+		o && (--o.refCount, this.statsData.releases += 1);
+	}
+	stats() {
+		return {
+			...this.statsData,
+			entries: this.store.size,
+			inFlight: this.inFlight.size
+		};
+	}
+	resetStats() {
+		this.statsData = createBucketStats();
+	}
+	clear() {
+		this.store.clear(), this.inFlight.clear();
+	}
+};
+const sharedDidCache = new DidCache(), sharedBlobCache = new BlobCache(), sharedRecordCache = new RecordCache(), sharedPaginatedRecordsCache = new PaginatedRecordsCache();
+function getSharedCaches() {
+	return {
+		didCache: sharedDidCache,
+		blobCache: sharedBlobCache,
+		recordCache: sharedRecordCache,
+		paginatedRecordsCache: sharedPaginatedRecordsCache
+	};
+}
+function getSharedCacheStats() {
+	return {
+		did: sharedDidCache.stats(),
+		blob: sharedBlobCache.stats(),
+		record: sharedRecordCache.stats(),
+		paginatedRecords: sharedPaginatedRecordsCache.stats()
+	};
+}
+function resetSharedCacheStats() {
+	sharedDidCache.resetStats(), sharedBlobCache.resetStats(), sharedRecordCache.resetStats(), sharedPaginatedRecordsCache.resetStats();
+}
+function clearSharedCaches() {
+	sharedDidCache.clear(), sharedBlobCache.clear(), sharedRecordCache.clear(), sharedPaginatedRecordsCache.clear();
+}
+export { BlobCache, DidCache, PaginatedRecordsCache, RecordCache, clearSharedCaches, getSharedCacheStats, getSharedCaches, resetSharedCacheStats, sharedBlobCache, sharedDidCache, sharedPaginatedRecordsCache, sharedRecordCache };

package/dist/client.d.ts

@@ -0,0 +1,45 @@
+import { Client } from "@atcute/client";
+import type { DidDocument } from "@atcute/identity";
+export interface ServiceResolverOptions {
+    plcDirectory?: string;
+    identityService?: string;
+    slingshotBaseUrl?: string;
+    fetch?: typeof fetch;
+}
+/**
+ * Default configuration values for AT Protocol services.
+ * These can be overridden via AtProtoProvider props.
+ */
+export declare const DEFAULT_CONFIG: {
+    readonly plcDirectory: "https://plc.directory";
+    readonly identityService: "https://public.api.bsky.app";
+    readonly slingshotBaseUrl: "https://slingshot.microcosm.blue";
+    readonly blueskyAppviewService: "https://public.api.bsky.app";
+    readonly blueskyAppBaseUrl: "https://bsky.app";
+    readonly tangledBaseUrl: "https://tangled.org";
+    readonly constellationBaseUrl: "https://constellation.microcosm.blue";
+};
+export declare const SLINGSHOT_BASE_URL = "https://slingshot.microcosm.blue";
+export declare const normalizeBaseUrl: (input: string) => string;
+export declare class ServiceResolver {
+    private plc;
+    private slingshot;
+    private didResolver;
+    private handleResolver;
+    private fetchImpl;
+    constructor(opts?: ServiceResolverOptions);
+    resolveDidDoc(did: string): Promise<DidDocument>;
+    pdsEndpointForDid(did: string): Promise<string>;
+    getSlingshotUrl(): string;
+    resolveHandle(handle: string): Promise<string>;
+}
+export interface CreateClientOptions extends ServiceResolverOptions {
+    did?: string;
+    service?: string;
+}
+export declare function createAtprotoClient(opts?: CreateClientOptions): Promise<{
+    rpc: Client<import("@atcute/lexicons/ambient").XRPCQueries, import("@atcute/lexicons/ambient").XRPCProcedures>;
+    service: string;
+    resolver: ServiceResolver;
+}>;
+export type AtprotoClient = Awaited<ReturnType<typeof createAtprotoClient>>["rpc"];