@ewanc26/svelte-standard-site 0.2.0

package/dist/schemas.js

@@ -0,0 +1,113 @@
+/**
+ * Zod schemas for standard.site lexicons and configuration
+ */
+import { z } from 'zod';
+/**
+ * AT Protocol collections
+ */
+export const COLLECTIONS = {
+    DOCUMENT: 'site.standard.document',
+    PUBLICATION: 'site.standard.publication'
+};
+/**
+ * RGB Color schema
+ */
+export const RGBColorSchema = z.object({
+    r: z.number().int().min(0).max(255),
+    g: z.number().int().min(0).max(255),
+    b: z.number().int().min(0).max(255)
+});
+/**
+ * Basic Theme schema
+ */
+export const BasicThemeSchema = z.object({
+    $type: z.literal('site.standard.theme.basic').optional(),
+    background: RGBColorSchema,
+    foreground: RGBColorSchema,
+    accent: RGBColorSchema,
+    accentForeground: RGBColorSchema
+});
+/**
+ * Publication Preferences schema
+ */
+export const PublicationPreferencesSchema = z.object({
+    showInDiscover: z.boolean().optional(),
+    showComments: z.boolean().optional(),
+    showMentions: z.boolean().optional(),
+    showPrevNext: z.boolean().optional(),
+    showRecommends: z.boolean().optional()
+});
+/**
+ * AT Protocol Blob schema
+ */
+export const AtProtoBlobSchema = z.object({
+    $type: z.literal('blob'),
+    ref: z.object({
+        $link: z.string()
+    }),
+    mimeType: z.string(),
+    size: z.number().int().positive()
+});
+/**
+ * Strong Reference schema
+ */
+export const StrongRefSchema = z.object({
+    uri: z.string(),
+    cid: z.string()
+});
+/**
+ * Publication schema
+ */
+export const PublicationSchema = z.object({
+    $type: z.literal('site.standard.publication'),
+    name: z.string(),
+    url: z.string().url(),
+    description: z.string().optional(),
+    icon: AtProtoBlobSchema.optional(),
+    basicTheme: BasicThemeSchema.optional(),
+    preferences: PublicationPreferencesSchema.optional()
+});
+/**
+ * Document schema
+ */
+export const DocumentSchema = z.object({
+    $type: z.literal('site.standard.document'),
+    site: z.string(),
+    title: z.string(),
+    publishedAt: z.string().datetime(),
+    path: z.string().optional(),
+    description: z.string().optional(),
+    updatedAt: z.string().datetime().optional(),
+    tags: z.array(z.string()).optional(),
+    coverImage: AtProtoBlobSchema.optional(),
+    textContent: z.string().optional(),
+    content: z.unknown().optional(),
+    bskyPostRef: StrongRefSchema.optional(),
+    preferences: PublicationPreferencesSchema.optional()
+});
+/**
+ * Publisher configuration schema
+ */
+export const PublisherConfigSchema = z.object({
+    identifier: z.string(), // handle or DID
+    password: z.string(),
+    service: z.string().url().optional()
+});
+/**
+ * Reader/Client configuration schema
+ */
+export const ReaderConfigSchema = z.object({
+    did: z.string(),
+    pds: z.string().url().optional(),
+    cacheTTL: z.number().int().positive().optional()
+});
+/**
+ * Loader configuration schema
+ */
+export const LoaderConfigSchema = z.object({
+    repo: z.string(),
+    excludeSite: z.string().url().optional(),
+    publication: z.string().optional(),
+    limit: z.number().int().positive().default(100),
+    service: z.string().url().default('https://public.api.bsky.app')
+});

package/dist/stores/index.d.ts

@@ -0,0 +1 @@
+export { themeStore } from './theme.js';

package/dist/stores/index.js

@@ -0,0 +1 @@
+export { themeStore } from './theme.js';

package/dist/stores/theme.d.ts

@@ -0,0 +1,11 @@
+interface ThemeState {
+    isDark: boolean;
+    mounted: boolean;
+}
+export declare const themeStore: {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<ThemeState>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
+    init: () => (() => void) | undefined;
+    toggle: () => void;
+    setTheme: (isDark: boolean) => void;
+};
+export {};

package/dist/stores/theme.js

@@ -0,0 +1,67 @@
+import { writable } from 'svelte/store';
+import { browser } from '$app/environment';
+function createThemeStore() {
+    const { subscribe, set, update } = writable({
+        isDark: false,
+        mounted: false
+    });
+    return {
+        subscribe,
+        init: () => {
+            if (!browser)
+                return;
+            const stored = localStorage.getItem('theme');
+            const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+            const isDark = stored === 'dark' || (!stored && prefersDark);
+            update((state) => ({
+                ...state,
+                isDark,
+                mounted: true
+            }));
+            applyTheme(isDark);
+            // Listen for system preference changes
+            const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+            const handleChange = (e) => {
+                if (!localStorage.getItem('theme')) {
+                    update((state) => ({ ...state, isDark: e.matches }));
+                    applyTheme(e.matches);
+                }
+            };
+            mediaQuery.addEventListener('change', handleChange);
+            return () => {
+                mediaQuery.removeEventListener('change', handleChange);
+            };
+        },
+        toggle: () => {
+            if (!browser)
+                return;
+            update((state) => {
+                const newIsDark = !state.isDark;
+                localStorage.setItem('theme', newIsDark ? 'dark' : 'light');
+                applyTheme(newIsDark);
+                return { ...state, isDark: newIsDark };
+            });
+        },
+        setTheme: (isDark) => {
+            if (!browser)
+                return;
+            localStorage.setItem('theme', isDark ? 'dark' : 'light');
+            applyTheme(isDark);
+            update((state) => ({ ...state, isDark }));
+        }
+    };
+}
+function applyTheme(isDark) {
+    if (!browser)
+        return;
+    const htmlElement = document.documentElement;
+    if (isDark) {
+        htmlElement.classList.add('dark');
+        htmlElement.style.colorScheme = 'dark';
+    }
+    else {
+        htmlElement.classList.remove('dark');
+        htmlElement.style.colorScheme = 'light';
+    }
+}
+export const themeStore = createThemeStore();

package/dist/styles/base.css

@@ -0,0 +1,188 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+@import 'tailwindcss';
+@import './themes.css';
+
+@theme {
+	/* Font Family */
+	--font-family-sans:
+		'Inter', ui-sans-serif, system-ui, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji',
+		'Segoe UI Symbol', 'Noto Color Emoji';
+
+	/* Ink - Slate-tinted text (230°) */
+	--color-ink-50: light-dark(oklch(17.5% 0.012 230), oklch(97.6% 0.008 230));
+	--color-ink-100: light-dark(oklch(25% 0.022 230), oklch(93.2% 0.017 230));
+	--color-ink-200: light-dark(oklch(38.5% 0.037 230), oklch(85.2% 0.032 230));
+	--color-ink-300: light-dark(oklch(50.5% 0.052 230), oklch(75.2% 0.048 230));
+	--color-ink-400: light-dark(oklch(62% 0.065 230), oklch(65.2% 0.062 230));
+	--color-ink-500: light-dark(oklch(73% 0.078 230), oklch(55.2% 0.078 230));
+	--color-ink-600: light-dark(oklch(78% 0.062 230), oklch(45.2% 0.065 230));
+	--color-ink-700: light-dark(oklch(83.5% 0.048 230), oklch(35.2% 0.052 230));
+	--color-ink-800: light-dark(oklch(89% 0.032 230), oklch(25.2% 0.037 230));
+	--color-ink-900: light-dark(oklch(94.5% 0.017 230), oklch(18.2% 0.022 230));
+	--color-ink-950: light-dark(oklch(97.6% 0.008 230), oklch(12.5% 0.012 230));
+
+	/* Canvas - Slate-tinted backgrounds (230°) */
+	--color-canvas-50: light-dark(oklch(17.8% 0.014 230), oklch(98.6% 0.005 230));
+	--color-canvas-100: light-dark(oklch(25.8% 0.025 230), oklch(96.6% 0.011 230));
+	--color-canvas-200: light-dark(oklch(39.5% 0.042 230), oklch(92.5% 0.024 230));
+	--color-canvas-300: light-dark(oklch(52% 0.058 230), oklch(86.5% 0.038 230));
+	--color-canvas-400: light-dark(oklch(64% 0.072 230), oklch(80.5% 0.055 230));
+	--color-canvas-500: light-dark(oklch(75.5% 0.085 230), oklch(75.5% 0.068 230));
+	--color-canvas-600: light-dark(oklch(80.5% 0.055 230), oklch(64% 0.072 230));
+	--color-canvas-700: light-dark(oklch(86.5% 0.038 230), oklch(52% 0.058 230));
+	--color-canvas-800: light-dark(oklch(92.5% 0.024 230), oklch(39.5% 0.042 230));
+	--color-canvas-900: light-dark(oklch(96.6% 0.011 230), oklch(25.8% 0.025 230));
+	--color-canvas-950: light-dark(oklch(98.6% 0.005 230), oklch(17.8% 0.014 230));
+
+	/* Slate - Primary colors (230°) */
+	--color-primary-50: light-dark(oklch(18.2% 0.018 230), oklch(97.8% 0.012 230));
+	--color-primary-100: light-dark(oklch(26.5% 0.03 230), oklch(94.8% 0.022 230));
+	--color-primary-200: light-dark(oklch(40.5% 0.048 230), oklch(89.5% 0.042 230));
+	--color-primary-300: light-dark(oklch(54% 0.065 230), oklch(79.5% 0.062 230));
+	--color-primary-400: light-dark(oklch(66.5% 0.08 230), oklch(69.5% 0.078 230));
+	--color-primary-500: light-dark(oklch(78.5% 0.095 230), oklch(59.5% 0.095 230));
+	--color-primary-600: light-dark(oklch(82.2% 0.078 230), oklch(49.5% 0.08 230));
+	--color-primary-700: light-dark(oklch(86.5% 0.062 230), oklch(39.5% 0.065 230));
+	--color-primary-800: light-dark(oklch(91% 0.042 230), oklch(29.5% 0.048 230));
+	--color-primary-900: light-dark(oklch(95.8% 0.022 230), oklch(21.5% 0.03 230));
+	--color-primary-950: light-dark(oklch(98% 0.012 230), oklch(15.2% 0.018 230));
+
+	/* Steel Grey - Secondary colors (215°) */
+	--color-secondary-50: light-dark(oklch(18.5% 0.02 215), oklch(97.9% 0.013 215));
+	--color-secondary-100: light-dark(oklch(26.8% 0.033 215), oklch(95% 0.024 215));
+	--color-secondary-200: light-dark(oklch(41% 0.052 215), oklch(89.8% 0.045 215));
+	--color-secondary-300: light-dark(oklch(54.5% 0.07 215), oklch(80.2% 0.065 215));
+	--color-secondary-400: light-dark(oklch(67% 0.087 215), oklch(70.2% 0.082 215));
+	--color-secondary-500: light-dark(oklch(79% 0.103 215), oklch(60.2% 0.103 215));
+	--color-secondary-600: light-dark(oklch(82.8% 0.082 215), oklch(50.2% 0.087 215));
+	--color-secondary-700: light-dark(oklch(87% 0.065 215), oklch(40.2% 0.07 215));
+	--color-secondary-800: light-dark(oklch(91.5% 0.045 215), oklch(30.5% 0.052 215));
+	--color-secondary-900: light-dark(oklch(96% 0.024 215), oklch(22.2% 0.033 215));
+	--color-secondary-950: light-dark(oklch(98.2% 0.013 215), oklch(15.8% 0.02 215));
+
+	/* Charcoal - Accent colors (240°) */
+	--color-accent-50: light-dark(oklch(18.5% 0.022 240), oklch(98% 0.014 240));
+	--color-accent-100: light-dark(oklch(26.8% 0.036 240), oklch(95.2% 0.026 240));
+	--color-accent-200: light-dark(oklch(41% 0.058 240), oklch(90% 0.048 240));
+	--color-accent-300: light-dark(oklch(54.5% 0.078 240), oklch(80.8% 0.072 240));
+	--color-accent-400: light-dark(oklch(67% 0.097 240), oklch(71% 0.092 240));
+	--color-accent-500: light-dark(oklch(79% 0.115 240), oklch(61% 0.115 240));
+	--color-accent-600: light-dark(oklch(82.8% 0.092 240), oklch(51% 0.097 240));
+	--color-accent-700: light-dark(oklch(87% 0.072 240), oklch(41% 0.078 240));
+	--color-accent-800: light-dark(oklch(91.5% 0.048 240), oklch(31% 0.058 240));
+	--color-accent-900: light-dark(oklch(96% 0.026 240), oklch(22.5% 0.036 240));
+	--color-accent-950: light-dark(oklch(98.2% 0.014 240), oklch(16.2% 0.022 240));
+}
+
+@layer base {
+	/* Base styles for consistent typography and accessibility */
+	html {
+		scroll-behavior: smooth;
+		overflow-x: hidden;
+		width: 100%;
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		html {
+			scroll-behavior: auto;
+		}
+
+		*,
+		*::before,
+		*::after {
+			animation-duration: 0.01ms !important;
+			animation-iteration-count: 1 !important;
+			transition-duration: 0.01ms !important;
+		}
+	}
+
+	body {
+		font-family: var(--font-family-sans);
+		text-rendering: optimizeLegibility;
+		-webkit-font-smoothing: antialiased;
+		-moz-osx-font-smoothing: grayscale;
+		overflow-x: hidden;
+		width: 100%;
+		max-width: 100vw;
+		background-color: var(--color-canvas-50);
+	}
+
+	@media (prefers-color-scheme: dark) {
+		body {
+			background-color: var(--color-canvas-950);
+		}
+	}
+
+	/* Skip to content link for keyboard navigation */
+	.skip-to-content {
+		position: absolute;
+		left: -9999px;
+		z-index: 999;
+		padding: 1rem 1.5rem;
+		background-color: var(--color-primary-600);
+		color: white;
+		font-weight: 600;
+		text-decoration: none;
+		border-radius: 0.5rem;
+	}
+
+	.skip-to-content:focus {
+		left: 1rem;
+		top: 1rem;
+		outline: 2px solid var(--color-primary-800);
+		outline-offset: 2px;
+	}
+
+	/* Focus visible styles for accessibility - Enhanced for better visibility */
+	*:focus-visible {
+		outline: 3px solid var(--color-primary-600);
+		outline-offset: 2px;
+		border-radius: 0.25rem;
+	}
+
+	/* High contrast mode support */
+	@media (prefers-contrast: high) {
+		*:focus-visible {
+			outline-width: 4px;
+		}
+	}
+
+	/* Ensure all elements stay within viewport */
+	* {
+		min-width: 0;
+	}
+
+	img,
+	video,
+	iframe,
+	embed,
+	object {
+		max-width: 100%;
+		height: auto;
+	}
+
+	/* Improve link accessibility */
+	a {
+		text-decoration-skip-ink: auto;
+	}
+
+	/* Better button accessibility */
+	button:disabled {
+		cursor: not-allowed;
+	}
+
+	/* Screen reader only utility */
+	.sr-only {
+		position: absolute;
+		width: 1px;
+		height: 1px;
+		padding: 0;
+		margin: -1px;
+		overflow: hidden;
+		clip: rect(0, 0, 0, 0);
+		white-space: nowrap;
+		border-width: 0;
+	}
+}
+
+@plugin '@tailwindcss/typography';

package/dist/styles/themes.css

@@ -0,0 +1,5 @@
+/* Color Theme System - Modular Theme Imports */
+/* Slate theme is the default and included in base.css */
+/* Add additional themes here as needed */
+
+/* Default theme is Slate (230°) defined in base.css */

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Core types for site.standard.* lexicons
+ */
+/**
+ * AT Protocol blob reference
+ */
+export interface AtProtoBlob {
+    $type: 'blob';
+    ref: {
+        $link: string;
+    };
+    mimeType: string;
+    size: number;
+}
+/**
+ * Strong reference to another AT Protocol record
+ */
+export interface StrongRef {
+    uri: string;
+    cid: string;
+}
+/**
+ * RGB Color
+ */
+export interface RGBColor {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Basic theme for publications
+ */
+export interface BasicTheme {
+    $type?: 'site.standard.theme.basic';
+    background: RGBColor;
+    foreground: RGBColor;
+    accent: RGBColor;
+    accentForeground: RGBColor;
+}
+/**
+ * Publication preferences
+ */
+export interface PublicationPreferences {
+    showInDiscover?: boolean;
+    showComments?: boolean;
+    showMentions?: boolean;
+    showPrevNext?: boolean;
+    showRecommends?: boolean;
+}
+/**
+ * Site Standard Publication record
+ */
+export interface Publication {
+    $type: 'site.standard.publication';
+    url: string;
+    name: string;
+    icon?: string;
+    description?: string;
+    basicTheme?: BasicTheme;
+    preferences?: PublicationPreferences;
+}
+/**
+ * Site Standard Document record
+ */
+export interface Document {
+    $type: 'site.standard.document';
+    site: string;
+    title: string;
+    path?: string;
+    description?: string;
+    coverImage?: string;
+    content?: any;
+    textContent?: string;
+    bskyPostRef?: StrongRef;
+    tags?: string[];
+    publishedAt: string;
+    updatedAt?: string;
+    preferences?: PublicationPreferences;
+}
+/**
+ * AT Protocol record response
+ */
+export interface AtProtoRecord<T = any> {
+    uri: string;
+    cid: string;
+    value: T;
+}
+/**
+ * Resolved identity from PDS resolution
+ */
+export interface ResolvedIdentity {
+    did: string;
+    pds: string;
+    handle?: string;
+}
+/**
+ * Configuration for the library
+ */
+export interface SiteStandardConfig {
+    /** The DID to fetch records from */
+    did: string;
+    /** Optional custom PDS endpoint */
+    pds?: string;
+    /** Cache TTL in milliseconds (default: 5 minutes) */
+    cacheTTL?: number;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Core types for site.standard.* lexicons
+ */
+export {};

package/dist/utils/agents.d.ts

@@ -0,0 +1,35 @@
+import { AtpAgent } from '@atproto/api';
+import type { ResolvedIdentity } from '../types.js';
+/**
+ * Creates an AtpAgent with optional fetch function injection
+ */
+export declare function createAgent(service: string, fetchFn?: typeof fetch): AtpAgent;
+/**
+ * Resolves a DID to find its PDS endpoint using Slingshot
+ * @param did - DID to resolve
+ * @param fetchFn - Optional fetch function for SSR
+ * @returns Resolved identity with PDS endpoint
+ */
+export declare function resolveIdentity(did: string, fetchFn?: typeof fetch): Promise<ResolvedIdentity>;
+/**
+ * Gets or creates a PDS-specific agent
+ * @param did - DID to resolve PDS for
+ * @param fetchFn - Optional fetch function for SSR
+ * @returns AtpAgent configured for the user's PDS
+ */
+export declare function getPDSAgent(did: string, fetchFn?: typeof fetch): Promise<AtpAgent>;
+/**
+ * Executes a function with automatic fallback
+ * @param did - The DID to resolve
+ * @param operation - The operation to execute
+ * @param fetchFn - Optional fetch function for SSR
+ */
+export declare function withFallback<T>(did: string, operation: (agent: AtpAgent) => Promise<T>, fetchFn?: typeof fetch): Promise<T>;
+/**
+ * Build a PDS blob URL
+ * @param pds - PDS endpoint
+ * @param did - Repository DID
+ * @param cid - Blob CID
+ * @returns Full blob URL
+ */
+export declare function buildPdsBlobUrl(pds: string, did: string, cid: string): string;

package/dist/utils/agents.js

@@ -0,0 +1,96 @@
+import { AtpAgent } from '@atproto/api';
+import { cache } from './cache.js';
+/**
+ * Creates an AtpAgent with optional fetch function injection
+ */
+export function createAgent(service, fetchFn) {
+    const wrappedFetch = fetchFn
+        ? async (url, init) => {
+            const urlStr = url instanceof URL ? url.toString() : url;
+            const response = await fetchFn(urlStr, init);
+            const headers = new Headers(response.headers);
+            if (!headers.has('content-type')) {
+                headers.set('content-type', 'application/json');
+            }
+            return new Response(response.body, {
+                status: response.status,
+                statusText: response.statusText,
+                headers
+            });
+        }
+        : undefined;
+    return new AtpAgent({
+        service,
+        ...(wrappedFetch && { fetch: wrappedFetch })
+    });
+}
+/**
+ * Resolves a DID to find its PDS endpoint using Slingshot
+ * @param did - DID to resolve
+ * @param fetchFn - Optional fetch function for SSR
+ * @returns Resolved identity with PDS endpoint
+ */
+export async function resolveIdentity(did, fetchFn) {
+    const cacheKey = `identity:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const _fetch = fetchFn ?? globalThis.fetch;
+    const response = await _fetch(`https://slingshot.microcosm.blue/xrpc/com.bad-example.identity.resolveMiniDoc?identifier=${encodeURIComponent(did)}`);
+    if (!response.ok) {
+        throw new Error(`Failed to resolve DID: ${response.status} ${response.statusText}`);
+    }
+    const rawText = await response.text();
+    const data = JSON.parse(rawText);
+    if (!data.did || !data.pds) {
+        throw new Error('Invalid response from identity resolver');
+    }
+    cache.set(cacheKey, data);
+    return data;
+}
+/**
+ * Gets or creates a PDS-specific agent
+ * @param did - DID to resolve PDS for
+ * @param fetchFn - Optional fetch function for SSR
+ * @returns AtpAgent configured for the user's PDS
+ */
+export async function getPDSAgent(did, fetchFn) {
+    const resolved = await resolveIdentity(did, fetchFn);
+    return createAgent(resolved.pds, fetchFn);
+}
+/**
+ * Executes a function with automatic fallback
+ * @param did - The DID to resolve
+ * @param operation - The operation to execute
+ * @param fetchFn - Optional fetch function for SSR
+ */
+export async function withFallback(did, operation, fetchFn) {
+    const agents = [
+        () => getPDSAgent(did, fetchFn),
+        () => Promise.resolve(fetchFn
+            ? createAgent('https://public.api.bsky.app', fetchFn)
+            : createAgent('https://public.api.bsky.app'))
+    ];
+    let lastError;
+    for (const getAgent of agents) {
+        try {
+            const agent = await getAgent();
+            return await operation(agent);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError;
+}
+/**
+ * Build a PDS blob URL
+ * @param pds - PDS endpoint
+ * @param did - Repository DID
+ * @param cid - Blob CID
+ * @returns Full blob URL
+ */
+export function buildPdsBlobUrl(pds, did, cid) {
+    const pdsBase = pds.replace(/\/$/, '');
+    return `${pdsBase}/xrpc/com.atproto.sync.getBlob?did=${encodeURIComponent(did)}&cid=${encodeURIComponent(cid)}`;
+}

package/dist/utils/at-uri.d.ts

@@ -0,0 +1,50 @@
+/**
+ * AT URI parsing and conversion utilities
+ */
+/**
+ * Parsed AT URI components
+ */
+export interface ParsedAtUri {
+    did: string;
+    collection: string;
+    rkey: string;
+}
+/**
+ * Parse an AT URI into its components
+ * @param atUri - AT URI in format: at://did:plc:xxx/collection/rkey
+ * @returns Parsed components or null if invalid
+ */
+export declare function parseAtUri(atUri: string): ParsedAtUri | null;
+/**
+ * Convert AT URI to HTTPS URL for com.atproto.repo.getRecord
+ * @param atUri - AT URI in format: at://did:plc:xxx/collection/rkey
+ * @param pdsEndpoint - PDS endpoint (e.g., "https://cortinarius.us-west.host.bsky.network")
+ * @returns HTTPS URL for getRecord XRPC call
+ */
+export declare function atUriToHttps(atUri: string, pdsEndpoint: string): string | null;
+/**
+ * Construct an AT URI from components
+ * @param did - DID of the repository
+ * @param collection - Collection name
+ * @param rkey - Record key
+ * @returns AT URI string
+ */
+export declare function buildAtUri(did: string, collection: string, rkey: string): string;
+/**
+ * Extract rkey from an AT URI
+ * @param atUri - AT URI
+ * @returns rkey or null if invalid
+ */
+export declare function extractRkey(atUri: string): string | null;
+/**
+ * Validate if string is a valid AT URI
+ * @param uri - String to validate
+ * @returns true if valid AT URI
+ */
+export declare function isAtUri(uri: string): boolean;
+/**
+ * Convert DID to PDS hostname format
+ * @param did - DID to convert
+ * @returns PDS hostname or null if unable to derive
+ */
+export declare function didToPdsHostname(did: string): string | null;