@repodeckhz/core 0.6.0

package/dist/index.d.cts

@@ -0,0 +1,616 @@
+/**
+ * @repodeckhz/core — errors.ts
+ *
+ * Single typed error used across the whole package so consumers can branch on
+ * `error.code` instead of parsing message strings.
+ *
+ * The class is exported under two names — `RepoDeckError` is the canonical
+ * name going forward; `repodeckError` is kept as an alias for the legacy
+ * `repodeck` rebrand that still appears in some docs and modules. Both
+ * resolve to the same class, so `instanceof` checks work either way.
+ */
+type RepoDeckErrorCode = 'NOT_FOUND' | 'RATE_LIMITED' | 'UNAUTHORIZED' | 'NETWORK_ERROR' | 'INVALID_CONFIG';
+/** Legacy alias used by modules still on the `repodeck` branding. */
+type repodeckErrorCode = RepoDeckErrorCode;
+declare class RepoDeckError extends Error {
+    code: RepoDeckErrorCode;
+    status?: number;
+    field?: string;
+    constructor(code: RepoDeckErrorCode, message: string, opts?: {
+        status?: number;
+        field?: string;
+        cause?: unknown;
+    });
+    toJSON(): {
+        name: string;
+        code: RepoDeckErrorCode;
+        message: string;
+        status: number | undefined;
+        field: string | undefined;
+    };
+}
+declare const repodeckError: typeof RepoDeckError;
+
+/**
+ * @repodeckhz/core — types.ts
+ *
+ * Shared data shapes used by every module of the core and by the API contract.
+ */
+
+interface FetchOptions {
+    /** GitHub personal access token (optional — bumps rate limit). */
+    token?: string;
+    /** Branch / tag / commit to read from. */
+    branch?: string;
+    /** Per-request timeout in ms. */
+    timeoutMs?: number;
+    /** Number of retries for transient network errors (never retries 404/401). */
+    retries?: number;
+}
+interface DirectoryEntry {
+    name: string;
+    path: string;
+    download_url: string | null;
+    size: number;
+}
+interface RateLimitInfo {
+    remaining: number;
+    limit: number;
+    resetAt: number;
+}
+interface ResumeData {
+    text: string;
+    truncated: boolean;
+    /** Which locale file was used (plan §16.19). Undefined = default RESUME.txt. */
+    locale?: string;
+}
+interface ReadmeData {
+    html: string;
+    raw: string;
+    /** Optional frontmatter parsed from the top of README.md (plan §16.18).
+     * Supports: title, accent (hex color), order (number), description, tags. */
+    frontmatter?: Record<string, string | number>;
+}
+interface Screenshot {
+    url: string;
+    filename: string;
+    alt: string;
+}
+interface CardMeta {
+    owner: string;
+    repo: string;
+    url: string;
+    branch: string;
+    configPath: string;
+    fetchedAt: number;
+}
+/** A field either resolved to data or carries a per-field RepoDeckError. */
+type FieldResult<T> = T | {
+    error: RepoDeckError;
+};
+interface CardData {
+    meta: CardMeta;
+    resume: FieldResult<ResumeData> | null;
+    readme: FieldResult<ReadmeData> | null;
+    screenshots: FieldResult<Screenshot[]> | null;
+    /** Optional repo stats (stars, forks, watchers) — only fetched when
+     * `include.stats` is true (typically via the `show-stats` attribute). */
+    stats?: FieldResult<RepoStats> | null;
+}
+interface RepoStats {
+    stars: number;
+    forks: number;
+    watchers: number;
+    openIssues: number;
+    defaultBranch: string;
+    pushedAt: number;
+    /** Repo name (e.g. "my-project"). */
+    repoName: string;
+    /** GitHub description field. */
+    repoDescription: string | null;
+    /** Repository topics (tags). */
+    topics: string[];
+    /** Primary language (e.g. "TypeScript"). */
+    language: string | null;
+    /** Homepage URL set in the repo settings. */
+    homepage: string | null;
+    /** Owner login. */
+    ownerLogin: string;
+    /** Owner avatar URL. */
+    ownerAvatarUrl: string;
+}
+interface BuildOptions {
+    include?: {
+        readme?: boolean;
+        resume?: boolean;
+        screenshots?: boolean;
+        stats?: boolean;
+    };
+    branch?: string;
+    configPath?: string;
+    token?: string;
+    /** Per-request timeout in ms (default 12000). */
+    timeoutMs?: number;
+    /** Retries on 5xx/network errors (default 2). */
+    retries?: number;
+    /** Resume char limit (default 280). */
+    resumeMaxChars?: number;
+    /** Locale for localized RESUME detection (plan §16.19). Tries
+     * `RESUME.<locale>.txt` before falling back to `RESUME.txt`. */
+    locale?: string;
+    /** Log per-field fetches, cache hits and errors (or REPODECK_DEBUG=1). */
+    debug?: boolean;
+}
+interface PresetDefinition {
+    /** Which fields to fetch from GitHub. */
+    include: {
+        readme: boolean;
+        resume: boolean;
+        screenshots: boolean;
+    };
+    /** Whether the card shows a README preview line. */
+    readmePreview: boolean;
+    /** Max chars of the README preview on the card. */
+    readmePreviewChars?: number;
+    /** Show repo title (always true, kept for completeness). */
+    showTitle: boolean;
+}
+interface ResolvedConfig extends PresetDefinition {
+    name: string;
+}
+type RadiusPresetName = 'sharp' | 'soft' | 'round';
+interface RadiusTokens {
+    card: string;
+    button: string;
+    modal: string;
+}
+type ScreenshotLayoutMode = 'single' | 'bento';
+interface LayoutItem {
+    screenshot: Screenshot;
+    /** grid-column span */
+    colSpan: number;
+    /** grid-row span */
+    rowSpan: number;
+    /** whether this is the "hero" tile */
+    hero: boolean;
+    /** "+N" overlay count, only set on the last visible tile when overflowing */
+    overflow?: number;
+}
+interface ScreenshotLayout {
+    mode: ScreenshotLayoutMode;
+    items: LayoutItem[];
+    total: number;
+    hidden: number;
+}
+
+/**
+ * @repodeckhz/core — cache.ts
+ *
+ * In-memory cache (Map) with TTL. Encapsulated in a `Cache` class so consumers
+ * can create isolated instances or share a singleton. The interface is
+ * designed to be swapped for a localStorage or Redis adapter without touching
+ * the rest of the core.
+ */
+interface CacheEntry<T = unknown> {
+    value: T;
+    expiresAt: number;
+}
+/**
+ * TTL-based in-memory cache. Create one instance and share it, or create
+ * separate instances for different TTLs/scopes.
+ */
+declare class Cache {
+    private defaultTtlMs;
+    private store;
+    constructor(defaultTtlMs?: number);
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T, ttlMs?: number): void;
+    /** Returns the cached entry including its expiry (for introspection). */
+    getEntry<T = unknown>(key: string): CacheEntry<T> | undefined;
+    delete(key: string): void;
+    clear(): void;
+    get size(): number;
+    /** Builds a deterministic cache key from card request parameters. */
+    static buildKey(parts: {
+        owner: string;
+        repo: string;
+        branch: string;
+        configPath: string;
+        include: string;
+    }): string;
+}
+declare function getCached<T = unknown>(key: string): CacheEntry<T> | undefined;
+declare function setCached<T = unknown>(key: string, value: T, ttlMs?: number): void;
+declare function clearCache(key?: string): void;
+declare function buildCacheKey(parts: {
+    owner: string;
+    repo: string;
+    branch: string;
+    configPath: string;
+    include: string;
+}): string;
+
+/**
+ * @repodeckhz/core — presets.ts
+ *
+ * Presets define "what shows on the compact card" vs "what is available in the
+ * modal". Consumers can register their own preset without forking.
+ */
+
+declare const defaultPresets: Record<string, PresetDefinition>;
+declare function registerPreset(name: string, definition: PresetDefinition): void;
+declare function getPreset(name: string): PresetDefinition;
+declare function listPresets(): string[];
+declare function mergePresetWithUserConfig(preset: PresetDefinition, overrides: Partial<PresetDefinition>, name?: string): ResolvedConfig;
+
+/**
+ * @repodeckhz/core — radius.ts
+ *
+ * Translates the `radius` attribute (preset name OR raw CSS value) into the
+ * three tokens used internally. Each token can be individually overridden via
+ * CSS custom properties on the host.
+ */
+
+declare function resolveRadiusTokens(radiusAttr: string): RadiusTokens;
+
+/**
+ * @repodeckhz/core — layout.ts
+ *
+ * Decides how screenshots are laid out.
+ *  - 1 image  → `single` (cover)
+ *  - 2+ images → `bento` (asymmetric grid, deterministic spans)
+ *
+ * Spans are deterministic (not random) so the layout never "jumps" between
+ * re-renders. The first image is always the hero (because screenshots are
+ * sorted alphabetically upstream, naming `01-capa.png` makes it the cover).
+ */
+
+/**
+ * Deterministic bento span map.
+ *  - 2 images: hero spans 2 cols, second spans 1
+ *  - 3 images: hero 2x2, others 1x1 stacked
+ *  - 4+ images: 2x2 mosaic, first tile always hero
+ */
+declare function assignBentoSpans(count: number): Array<{
+    colSpan: number;
+    rowSpan: number;
+    hero: boolean;
+}>;
+declare function resolveScreenshotLayout(screenshots: Screenshot[], context: 'card' | 'modal'): ScreenshotLayout;
+
+/**
+ * @repodeckhz/core — github-client.ts
+ *
+ * All communication with the GitHub REST API. Encapsulated in a `GitHubClient`
+ * class so consumers can configure token/retry/timeout once and inject the
+ * instance wherever needed (dependency injection).
+ *
+ * 404 → returns null (so a missing field doesn't break the whole card);
+ * any other failure throws repodeckError.
+ */
+
+interface GitHubClientOptions {
+    /** GitHub personal access token — bumps rate limit from 60 to 5000 req/h. */
+    token?: string;
+    /** Per-request timeout in ms (default 12000). */
+    timeoutMs?: number;
+    /** Retries on 5xx/network errors (default 2). Never retries 404/401/403. */
+    retries?: number;
+    /** Log every request (method, path, status, duration, rate-limit headers). */
+    debug?: boolean;
+}
+/**
+ * Encapsulates all GitHub REST API access. Stateless aside from config —
+ * safe to share a single instance across calls.
+ */
+declare class GitHubClient {
+    private readonly token?;
+    private readonly timeoutMs;
+    private readonly retries;
+    private readonly debug;
+    constructor(options?: GitHubClientOptions);
+    /** Creates a client from `FetchOptions` (backward-compatible with the old API). */
+    static from(options?: {
+        token?: string;
+        timeoutMs?: number;
+        retries?: number;
+        debug?: boolean;
+    }): GitHubClient;
+    private headers;
+    /** Retry wrapper — only retries on network errors / 5xx, never on 404/401/403. */
+    private fetchWithRetry;
+    private static decodeBase64;
+    /** Fetches a single file's content. 404 → null (not an error). */
+    fetchFileContent(owner: string, repo: string, path: string, ref?: string): Promise<string | null>;
+    /** Lists files in a directory. 404 → empty array. */
+    fetchDirectoryListing(owner: string, repo: string, path: string, ref?: string): Promise<DirectoryEntry[]>;
+    /** Fetches repo metadata and statistics in a single API call. */
+    fetchRepoStats(owner: string, repo: string): Promise<RepoStats>;
+    /** Checks the current rate-limit budget. */
+    checkRateLimit(): Promise<RateLimitInfo>;
+    private assertOk;
+}
+/** Builds a raw.githubusercontent.com URL (efficient for <img src>). */
+declare function buildRawUrl(owner: string, repo: string, branch: string, path: string): string;
+declare function fetchFileContent(owner: string, repo: string, path: string, options?: {
+    token?: string;
+    branch?: string;
+    timeoutMs?: number;
+    retries?: number;
+}): Promise<string | null>;
+declare function fetchDirectoryListing(owner: string, repo: string, path: string, options?: {
+    token?: string;
+    branch?: string;
+    timeoutMs?: number;
+    retries?: number;
+}): Promise<DirectoryEntry[]>;
+declare function fetchRepoStats(owner: string, repo: string, options?: {
+    token?: string;
+    timeoutMs?: number;
+    retries?: number;
+}): Promise<RepoStats>;
+declare function checkRateLimit(options?: {
+    token?: string;
+    timeoutMs?: number;
+    retries?: number;
+}): Promise<RateLimitInfo>;
+
+/**
+ * @repodeckhz/core — parser.ts
+ *
+ * Transforms raw text from GitHub into display-ready data.
+ *
+ * Security: README content comes from third-party repos, so markdown→HTML is
+ * followed by sanitization (isomorphic-dompurify) to neutralise XSS.
+ *
+ * Performance: `marked` and `isomorphic-dompurify` are lazy-loaded on first
+ * `parseReadme` call — consumers that only use `parseResume` /
+ * `resolveScreenshots` never pay the cost of loading these heavy deps.
+ */
+
+/**
+ * Parses YAML-like frontmatter from the top of README.md (plan §16.18).
+ * Supports: title, accent (hex color), order (number), description, tags.
+ * Returns { metadata, content } where content is the markdown with frontmatter
+ * stripped.
+ */
+declare function parseReadmeFrontmatter(rawMarkdown: string): {
+    metadata: Record<string, string | number>;
+    content: string;
+};
+/**
+ * Normalises RESUME.txt: collapses excessive whitespace, applies a configurable
+ * char limit. Returns a `truncated` flag so the UI can show "…" / a "see more"
+ * affordance that opens the modal.
+ */
+declare function parseResume(rawText: string, options?: {
+    maxChars?: number;
+}): ResumeData;
+/**
+ * Converts Markdown → sanitized HTML. No truncation (the modal shows the full
+ * README with internal scroll — see plan §8).
+ * Also extracts frontmatter (plan §16.18) so the web component can apply
+ * per-project accent color + title overrides without extra config on the
+ * embedder's side.
+ *
+ * Async because `marked` + `isomorphic-dompurify` are lazy-loaded on first
+ * call — keeping the initial bundle light.
+ */
+declare function parseReadme(rawMarkdown: string): Promise<ReadmeData>;
+/**
+ * Filters the screenshots/ listing to valid image extensions, sorts
+ * alphabetically (so `01-`, `02-` prefixes give a stable order), and resolves
+ * each to a raw.githubusercontent.com URL.
+ */
+declare function resolveScreenshots(entries: DirectoryEntry[], owner: string, repo: string, branch: string): Screenshot[];
+
+/**
+ * @repodeckhz/core — builder.ts
+ *
+ * The orchestrator. `CardBuilder` takes a `GitHubClient` (dependency injection)
+ * and an optional `Cache`, then builds a `CardData` object by firing only the
+ * fetches the caller asked for — in parallel, with per-field error isolation.
+ *
+ * Per-field error model (closed decision — plan §3.3 / §15):
+ *   If RESUME.txt is missing but README.md exists, the card still builds with
+ *   `resume` carrying a repodeckError. Never "all-or-nothing".
+ */
+
+declare function validateConfig(owner: unknown, repo: unknown, options?: BuildOptions): void;
+/**
+ * Orchestrates card data assembly. Inject a `GitHubClient` (and optionally a
+ * `Cache`) so the builder is fully decoupled from I/O — easy to test with
+ * mocks.
+ */
+declare class CardBuilder {
+    private readonly client;
+    private readonly cache?;
+    constructor(client?: GitHubClient, cache?: Cache | undefined);
+    build(owner: string, repo: string, options?: BuildOptions): Promise<CardData>;
+    private fetchResume;
+    private fetchReadme;
+    private fetchScreenshots;
+    private fetchStats;
+    /** Wraps a fetcher in try/catch, converting errors to per-field repodeckError. */
+    private safeFetch;
+}
+/**
+ * Builds card data for a GitHub repo. Creates a one-shot `CardBuilder` with a
+ * default `GitHubClient`. For repeated calls, create a `CardBuilder` once and
+ * reuse it (enables connection reuse + caching).
+ */
+declare function buildCardData(owner: string, repo: string, options?: BuildOptions): Promise<CardData>;
+
+/**
+ * @repodeckhz/core — prefetch.ts
+ *
+ * Build-time / batch fetching. Takes a list of
+ * `{ owner, repo, branch?, configPath?, include? }` and resolves them all
+ * concurrently (bounded by a small worker pool) so a static site can ship
+ * the resulting `CardData` to visitors without any runtime GitHub calls.
+ *
+ * Per the closed plan decision documented in §3.3 / §15, each repo's per-
+ * field errors are preserved: a missing RESUME.txt on one card doesn't
+ * stop the rest of the batch.
+ */
+
+interface PrefetchTarget {
+    owner: string;
+    repo: string;
+    branch?: string;
+    configPath?: string;
+    /** `include` mask — defaults to { readme, resume, screenshots: true } for each. */
+    include?: BuildOptions['include'];
+}
+interface PrefetchOptions {
+    /** Concurrency ceiling; default 4 (≈16 request-units per minute, comfortable even anonymous). */
+    concurrency?: number;
+    /** Per-card Token (or pass per-target): the global one is used when the target doesn't override. */
+    token?: string;
+    /** Optional shared cache so two prefetch calls don't refetch the same repo. */
+    cache?: Cache;
+    /** Optional list of fields to include by default; targets without a per-target `include` inherit this. */
+    include?: BuildOptions['include'];
+    /** Per-card `timeoutMs` (forwarded to GitHubClient). */
+    timeoutMs?: number;
+    /** Per-card `retries` (forwarded to GitHubClient). */
+    retries?: number;
+    /** Log batch progress and per-repo errors (or REPODECK_DEBUG=1). */
+    debug?: boolean;
+}
+/**
+ * Resolves many repos in parallel and returns a map keyed by `owner/repo`.
+ *
+ *   const cards = await prefetchCardData(
+ *     [{ owner: 'me', repo: 'a' }, { owner: 'me', repo: 'b' }],
+ *     { token: process.env.GITHUB_TOKEN, concurrency: 4 },
+ *   );
+ *   cards.get('me/a'); // → CardData
+ */
+declare function prefetchCardData(targets: PrefetchTarget[], options?: PrefetchOptions): Promise<Map<string, CardData>>;
+/**
+ * Public surface returned by `prefetchCardData`. Always a `Map<owner/repo,
+ * CardData>`, additionally decorated with the `errors` getter when at
+ * least one target threw a fatal error during the batch run.
+ *
+ *   const result = await prefetchCardData([...]);
+ *   for (const [key, card] of result) console.log(key, card.meta.url);
+ *   if (result.errors) {
+ *     for (const [key, err] of result.errors) console.warn(key, err);
+ *   }
+ */
+interface PrefetchResult extends Map<string, CardData> {
+    /** Map of `owner/repo` → fatal error. Empty on a fully successful run. */
+    readonly errors?: ReadonlyMap<string, unknown>;
+}
+
+/**
+ * @repodeckhz/core — graphql.ts
+ *
+ * Experimental GitHub GraphQL batch fetch (plan §16.6).
+ *
+ * One POST to `https://api.github.com/graphql` can resolve metadata + files
+ * for several repos at once, where N REST calls would be needed otherwise.
+ * For a 10-repo batch with resume + readme + screenshots + stats, REST costs
+ * roughly 4 × 10 = 40 request-units; GraphQL collapses that to 1 query (plus
+ * an auxiliary REST call per screenshots/ folder — the GraphQL Tree API can't
+ * enumerate the contents of a tree in the same request as the parent repo
+ * query without blowing past the complexity budget, so we keep that on REST
+ * and treat it as best-effort).
+ *
+ * Rate limit math (2026):
+ *   • GraphQL point cost is 1 point per request, NOT proportional to query
+ *     complexity (GitHub's points-per-call model, active since 2025).
+ *   • 5,000 points/hour with a token; ~1 h without (anonymous GraphQL is
+ *     rejected entirely). For batches, we split repos into groups of
+ *     `batchSize` (default 10) — each group is one request.
+ *
+ * Public surface:
+ *   • `GraphQLClient`           — minimal client (POST + bearer + retry).
+ *   • `fetchMultipleReposViaGraphQL(targets, options)` → Map<owner/repo, CardData>.
+ *
+ * The returned `CardData` is the same shape the REST path in `CardBuilder`
+ * produces, so consumers don't need to branch on transport.
+ */
+
+interface GraphQLBatchTarget {
+    owner: string;
+    repo: string;
+    /** Branch / ref to read from; default `main`. */
+    branch?: string;
+    /** Config folder path; default `config-repodeck`. */
+    configPath?: string;
+    /** Optional per-target `include` mask; inherits options.include otherwise. */
+    include?: BuildOptions['include'];
+    /** Optional per-target resume locale (e.g. `pt`). */
+    locale?: string;
+}
+interface GraphQLBatchOptions {
+    /** GitHub personal access token — required (anonymous GraphQL is rejected). */
+    token: string;
+    /** Max repos per GraphQL request (default 10). */
+    batchSize?: number;
+    /** Per-request timeout (default 30000 — GraphQL can take a while on big batches). */
+    timeoutMs?: number;
+    /** Retries on 5xx / network errors (default 2). */
+    retries?: number;
+    /** Per-batch default include mask; targets without `include` inherit this. */
+    include?: BuildOptions['include'];
+    /** Shared `GitHubClient` for the auxiliary REST screenshots/ call. */
+    restClient?: GitHubClient;
+    /** Resume char limit forwarded to parseResume. */
+    resumeMaxChars?: number;
+    /** Log batch plans, query sizes and per-repo errors (or REPODECK_DEBUG=1). */
+    debug?: boolean;
+}
+/**
+ * Minimal WebSocket-without-the-WS — a POST-only client for the GraphQL
+ * endpoint. Kept separate from `GitHubClient` because GraphQL has a
+ * different endpoint, different rate-limit semantics and no 404-as-null
+ * convention (errors come back inside the 200 body).
+ */
+declare class GraphQLClient {
+    private readonly token;
+    private readonly timeoutMs;
+    private readonly retries;
+    private readonly debug;
+    constructor(opts: {
+        token: string;
+        timeoutMs?: number;
+        retries?: number;
+        debug?: boolean;
+    });
+    /**
+     * POSTs a GraphQL query. Returns the `data` field of the response (already
+     * stripped of `errors`). Throws `RepoDeckError('NETWORK_ERROR', …)` on a
+     * non-2xx response, or `RepoDeckError` carrying the GraphQL errors when
+     * the response is 200 but carries `errors: [...]`.
+     */
+    request<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T>;
+}
+/**
+ * Fetches card data for multiple repos using a single GraphQL query per
+ * batch (default 10 repos per request). Returns a Map keyed by `owner/repo`
+ * with the same CardData shape the REST path produces.
+ *
+ *   const cards = await fetchMultipleReposViaGraphQL(
+ *     [{ owner: 'facebook', repo: 'react' }, { owner: 'vercel', repo: 'next.js' }],
+ *     { token: process.env.GITHUB_TOKEN },
+ *   );
+ *   cards.get('facebook/react'); // → CardData
+ *
+ * Partial errors:
+ *   Each repo resolves to either data or a per-field RepoDeckError, mirroring
+ *   `CardBuilder`. A repo whose `repository` query returns null (repo deleted
+ *   or inaccessible) produces a card with `stats`, `readme`, `resume` all
+ *   carrying `error: RepoDeckError('NOT_FOUND')`.
+ *
+ * Screenshots: per the closed decision above, screenshots/ are fetched via
+ * an auxiliary REST call (one per repo) after the GraphQL response lands.
+ * This keeps the GraphQL query complexity within limits while only adding
+ * one request per repo (12 REST requests for a 12-repo batch still beats
+ * 4 × 12 = 48 for pure REST).
+ */
+declare function fetchMultipleReposViaGraphQL(targets: GraphQLBatchTarget[], options: GraphQLBatchOptions): Promise<Map<string, CardData>>;
+
+export { type BuildOptions, Cache, type CacheEntry, CardBuilder, type CardData, type CardMeta, type DirectoryEntry, type FetchOptions, type FieldResult, GitHubClient, type GitHubClientOptions, type GraphQLBatchOptions, type GraphQLBatchTarget, GraphQLClient, type LayoutItem, type PrefetchOptions, type PrefetchResult, type PrefetchTarget, type PresetDefinition, type RadiusPresetName, type RadiusTokens, type RateLimitInfo, type ReadmeData, RepoDeckError, type RepoDeckErrorCode, type RepoStats, type ResolvedConfig, type ResumeData, type Screenshot, type ScreenshotLayout, type ScreenshotLayoutMode, assignBentoSpans, buildCacheKey, buildCardData, buildRawUrl, checkRateLimit, clearCache, defaultPresets, fetchDirectoryListing, fetchFileContent, fetchMultipleReposViaGraphQL, fetchRepoStats, getCached, getPreset, listPresets, mergePresetWithUserConfig, parseReadme, parseReadmeFrontmatter, parseResume, prefetchCardData, registerPreset, repodeckError, type repodeckErrorCode, resolveRadiusTokens, resolveScreenshotLayout, resolveScreenshots, setCached, validateConfig };