@lapis-notes/lapis-plugin-docs 0.0.0-stage → 0.1.0

package/dist/model/docs-card-preview-stack-motion.d.ts

@@ -0,0 +1,51 @@
+export declare const CARD_STACK_MOTION: {
+    readonly rotateFactor: 3.5;
+    readonly scaleFactor: 0.045;
+    readonly pivot: "50% 100%";
+    readonly kickMs: 200;
+    readonly settleMs: 500;
+    readonly promoteDelayMs: 150;
+    readonly totalMs: 700;
+    readonly visibleDepth: 3;
+};
+export declare const CARD_STACK_KICK: {
+    readonly x: "40%";
+    readonly y: "-8%";
+    readonly rotate: 14;
+    readonly scale: 0.8;
+};
+export declare const CARD_STACK_ANIMATION_NAMES: {
+    readonly kick: "docs-card-preview-deck-kick-next";
+    readonly settleBack: "docs-card-preview-deck-settle-back";
+    readonly dealFromBack: "docs-card-preview-deal-from-back";
+    readonly dealKickToFront: "docs-card-preview-deal-kick-to-front";
+    readonly promoteStep: "docs-card-preview-promote-step";
+    readonly fanStep: "docs-card-preview-fan-step";
+};
+export declare const CARD_STACK_SWIPE: {
+    readonly activationThresholdPx: 10;
+    readonly commitThresholdPx: 72;
+    readonly rotateFactor: 0.08;
+    readonly maxRotateDeg: 12;
+    readonly snapBackMs: 220;
+};
+export declare function swipeDragPose(deltaX: number): {
+    x: number;
+    rotate: number;
+};
+export declare function fanPose(depth: number): {
+    rotate: number;
+    scale: number;
+};
+export declare function fanStackOpacity(depth: number): 1 | 0.96 | 0.92;
+export declare function fanStackZIndex(depth: number): 1 | 2 | 3;
+export declare function fanTransform(depth: number): string;
+export type CardStackMode = 'browse' | 'study';
+export declare function wrappedCardIndex(index: number, cardCount: number): number;
+export declare function clampCardIndex(index: number, cardCount: number): number;
+export declare function resolveStackIndex(index: number, cardCount: number, mode: CardStackMode): number;
+export declare function nextStackIndex(index: number, cardCount: number, mode: CardStackMode, direction: 'next' | 'prev'): number;
+export declare function canNavigateStack(index: number, cardCount: number, mode: CardStackMode, direction: 'next' | 'prev'): boolean;
+export declare function cardDepthInStack(topIndex: number, targetIndex: number, cardCount: number, visibleDepth?: number): number;
+/** @deprecated Use cardDepthInStack with the start-state top index. */
+export declare function incomingFanDepth(incomingIndex: number, newTopIndex: number, cardCount: number, visibleDepth?: number): number;

package/dist/model/docs-card-preview-stack-motion.js

@@ -0,0 +1,94 @@
+export const CARD_STACK_MOTION = {
+    rotateFactor: 3.5,
+    scaleFactor: 0.045,
+    pivot: '50% 100%',
+    kickMs: 200,
+    settleMs: 500,
+    promoteDelayMs: 150,
+    totalMs: 700,
+    visibleDepth: 3
+};
+export const CARD_STACK_KICK = {
+    x: '40%',
+    y: '-8%',
+    rotate: 14,
+    scale: 0.8
+};
+export const CARD_STACK_ANIMATION_NAMES = {
+    kick: 'docs-card-preview-deck-kick-next',
+    settleBack: 'docs-card-preview-deck-settle-back',
+    dealFromBack: 'docs-card-preview-deal-from-back',
+    dealKickToFront: 'docs-card-preview-deal-kick-to-front',
+    promoteStep: 'docs-card-preview-promote-step',
+    fanStep: 'docs-card-preview-fan-step'
+};
+export const CARD_STACK_SWIPE = {
+    activationThresholdPx: 10,
+    commitThresholdPx: 72,
+    rotateFactor: 0.08,
+    maxRotateDeg: 12,
+    snapBackMs: 220
+};
+export function swipeDragPose(deltaX) {
+    const rotate = Math.max(-CARD_STACK_SWIPE.maxRotateDeg, Math.min(CARD_STACK_SWIPE.maxRotateDeg, deltaX * CARD_STACK_SWIPE.rotateFactor));
+    return { x: deltaX, rotate };
+}
+export function fanPose(depth) {
+    return {
+        rotate: depth * CARD_STACK_MOTION.rotateFactor,
+        scale: 1 - depth * CARD_STACK_MOTION.scaleFactor
+    };
+}
+export function fanStackOpacity(depth) {
+    if (depth <= 0)
+        return 1;
+    if (depth === 1)
+        return 0.96;
+    return 0.92;
+}
+export function fanStackZIndex(depth) {
+    if (depth <= 0)
+        return 3;
+    if (depth === 1)
+        return 2;
+    return 1;
+}
+export function fanTransform(depth) {
+    const { rotate, scale } = fanPose(depth);
+    return `rotate(${rotate}deg) scale(${scale})`;
+}
+export function wrappedCardIndex(index, cardCount) {
+    if (cardCount <= 0)
+        return 0;
+    return ((index % cardCount) + cardCount) % cardCount;
+}
+export function clampCardIndex(index, cardCount) {
+    if (cardCount <= 0)
+        return 0;
+    return Math.max(0, Math.min(index, cardCount - 1));
+}
+export function resolveStackIndex(index, cardCount, mode) {
+    return mode === 'browse' ? wrappedCardIndex(index, cardCount) : clampCardIndex(index, cardCount);
+}
+export function nextStackIndex(index, cardCount, mode, direction) {
+    const delta = direction === 'next' ? 1 : -1;
+    return resolveStackIndex(index + delta, cardCount, mode);
+}
+export function canNavigateStack(index, cardCount, mode, direction) {
+    if (cardCount <= 1 || cardCount === 0)
+        return false;
+    if (mode === 'browse')
+        return true;
+    if (direction === 'prev')
+        return index > 0;
+    return index < cardCount - 1;
+}
+export function cardDepthInStack(topIndex, targetIndex, cardCount, visibleDepth = CARD_STACK_MOTION.visibleDepth) {
+    const depth = wrappedCardIndex(targetIndex - topIndex, cardCount);
+    return Math.min(depth, visibleDepth - 1);
+}
+/** @deprecated Use cardDepthInStack with the start-state top index. */
+export function incomingFanDepth(incomingIndex, newTopIndex, cardCount, visibleDepth = CARD_STACK_MOTION.visibleDepth) {
+    const fromIndex = wrappedCardIndex(newTopIndex + 1, cardCount);
+    return cardDepthInStack(fromIndex, incomingIndex, cardCount, visibleDepth);
+}

package/dist/model/docs-media-context.d.ts

@@ -0,0 +1,9 @@
+import { type DocsMediaUrlResolver } from "./docs-relative-media";
+export type DocsMediaResolveResult = string | Promise<string>;
+export type DocsMediaResolver = (relativePath: string) => DocsMediaResolveResult;
+/** Sync mapper used during Carta rehype (always emits the sentinel). */
+export declare function docsMediaSentinelResolver(relativePath: string): string;
+export declare function setDocsMediaResolver(resolver: DocsMediaResolver): void;
+export declare function getDocsMediaResolver(): DocsMediaResolver;
+/** Default sync Carta plugin resolver: emit sentinel for post-render. */
+export declare function defaultDocsMediaPluginResolver(): DocsMediaUrlResolver;

package/dist/model/docs-media-context.js

@@ -0,0 +1,18 @@
+import { getContext, setContext } from "svelte";
+import { encodeDocsMediaSentinel, serverDocsMediaUrl, } from "./docs-relative-media";
+const DOCS_MEDIA_RESOLVER_CONTEXT = "cvstudio:docs-media-url-resolver";
+/** Sync mapper used during Carta rehype (always emits the sentinel). */
+export function docsMediaSentinelResolver(relativePath) {
+    return encodeDocsMediaSentinel(relativePath);
+}
+export function setDocsMediaResolver(resolver) {
+    setContext(DOCS_MEDIA_RESOLVER_CONTEXT, resolver);
+}
+export function getDocsMediaResolver() {
+    return (getContext(DOCS_MEDIA_RESOLVER_CONTEXT) ??
+        serverDocsMediaUrl);
+}
+/** Default sync Carta plugin resolver: emit sentinel for post-render. */
+export function defaultDocsMediaPluginResolver() {
+    return docsMediaSentinelResolver;
+}

package/dist/model/docs-note-list.d.ts

@@ -0,0 +1,8 @@
+import type { DocsNote, DocsNoteSummary } from "./types";
+/** Note-like rows used by sidebar lists (full notes or index summaries). */
+export type DocsNoteListItem = DocsNote | DocsNoteSummary;
+export declare function isDocsNoteSummary(note: DocsNoteListItem): note is DocsNoteSummary;
+export declare function docsNoteCardCount(note: DocsNoteListItem): number;
+export declare function docsNoteBlockCount(note: DocsNoteListItem): number;
+export declare function docsNoteBodyLength(note: DocsNoteListItem): number;
+export declare function docsNoteListKey(note: DocsNoteListItem): string;

package/dist/model/docs-note-list.js

@@ -0,0 +1,25 @@
+export function isDocsNoteSummary(note) {
+    return "cardCount" in note && !("blocks" in note);
+}
+export function docsNoteCardCount(note) {
+    if ("cardCount" in note && typeof note.cardCount === "number")
+        return note.cardCount;
+    if ("cards" in note && Array.isArray(note.cards))
+        return note.cards.length;
+    return 0;
+}
+export function docsNoteBlockCount(note) {
+    if ("blockCount" in note && typeof note.blockCount === "number")
+        return note.blockCount;
+    if ("blocks" in note && Array.isArray(note.blocks))
+        return note.blocks.length;
+    return 0;
+}
+export function docsNoteBodyLength(note) {
+    if ("body" in note && typeof note.body === "string")
+        return note.body.length;
+    return 0;
+}
+export function docsNoteListKey(note) {
+    return `${note.id}:${note.updatedAt}:${note.completedAt ?? ""}:${docsNoteBlockCount(note)}:${docsNoteCardCount(note)}:${docsNoteBodyLength(note)}`;
+}

package/dist/model/docs-relative-media.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resolve co-located docs media paths from markdown image `src` values.
+ * Leaves http(s), data:, and root-absolute paths unchanged.
+ * Relative paths resolve against the note file under `data/docs/`.
+ * Paths that escape `data/docs/` are left unchanged.
+ */
+/**
+ * Path-shaped sentinel so rehype-sanitize keeps the src (custom protocols
+ * like `cvstudio-docs-media:` are stripped and leave relative `../media/...`
+ * URLs that 404 as `/media/...` in the browser).
+ */
+export declare const DOCS_MEDIA_SENTINEL_PREFIX = "/__cvstudio-docs-media__/";
+export type DocsMediaUrlResolver = (relativePath: string) => string | Promise<string>;
+/** Encode a path under data/docs/ as a sync preview sentinel. */
+export declare function encodeDocsMediaSentinel(relativePath: string): string;
+/** Decode a sentinel back to a data/docs-relative path, or null. */
+export declare function decodeDocsMediaSentinel(src: string): string | null;
+/** Default server runtime URL for a path under data/docs/. */
+export declare function serverDocsMediaUrl(relativePath: string): string;
+/**
+ * Resolve a markdown image src to a path under `data/docs/` (without the prefix).
+ * Returns null for external, absolute, invalid, or escaping paths.
+ */
+export declare function resolveDocsMediaRelativePath(src: string, sourcePath: string): string | null;
+/**
+ * Rewrite a markdown image src for preview.
+ * By default emits the server API URL; pass `encodeDocsMediaSentinel` for
+ * deferred runtime resolution.
+ */
+export declare function rewriteDocsRelativeMediaSrc(src: string, sourcePath: string, resolveUrl?: DocsMediaUrlResolver): string;

package/dist/model/docs-relative-media.js

@@ -0,0 +1,116 @@
+/**
+ * Resolve co-located docs media paths from markdown image `src` values.
+ * Leaves http(s), data:, and root-absolute paths unchanged.
+ * Relative paths resolve against the note file under `data/docs/`.
+ * Paths that escape `data/docs/` are left unchanged.
+ */
+const DOCS_ROOT_PREFIX = "data/docs/";
+const MEDIA_API_PREFIX = "/api/docs/media/";
+/**
+ * Path-shaped sentinel so rehype-sanitize keeps the src (custom protocols
+ * like `cvstudio-docs-media:` are stripped and leave relative `../media/...`
+ * URLs that 404 as `/media/...` in the browser).
+ */
+export const DOCS_MEDIA_SENTINEL_PREFIX = "/__cvstudio-docs-media__/";
+function normalizeSourcePath(sourcePath) {
+    return sourcePath.trim().replace(/^\/+/, "").replaceAll("\\", "/");
+}
+function resolvePosix(baseDir, relative) {
+    const parts = baseDir.split("/").filter(Boolean);
+    for (const part of relative.replaceAll("\\", "/").split("/")) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..") {
+            if (parts.length === 0)
+                return null;
+            parts.pop();
+            continue;
+        }
+        parts.push(part);
+    }
+    return parts.join("/");
+}
+/** Encode a path under data/docs/ as a sync preview sentinel. */
+export function encodeDocsMediaSentinel(relativePath) {
+    return `${DOCS_MEDIA_SENTINEL_PREFIX}${relativePath
+        .split("/")
+        .map(encodeURIComponent)
+        .join("/")}`;
+}
+/** Decode a sentinel back to a data/docs-relative path, or null. */
+export function decodeDocsMediaSentinel(src) {
+    const trimmed = src.trim();
+    if (!trimmed.startsWith(DOCS_MEDIA_SENTINEL_PREFIX))
+        return null;
+    const encoded = trimmed.slice(DOCS_MEDIA_SENTINEL_PREFIX.length);
+    if (!encoded)
+        return null;
+    try {
+        return encoded
+            .split("/")
+            .map((segment) => decodeURIComponent(segment))
+            .join("/");
+    }
+    catch {
+        return null;
+    }
+}
+/** Default server runtime URL for a path under data/docs/. */
+export function serverDocsMediaUrl(relativePath) {
+    return `${MEDIA_API_PREFIX}${relativePath
+        .split("/")
+        .map(encodeURIComponent)
+        .join("/")}`;
+}
+/**
+ * Resolve a markdown image src to a path under `data/docs/` (without the prefix).
+ * Returns null for external, absolute, invalid, or escaping paths.
+ */
+export function resolveDocsMediaRelativePath(src, sourcePath) {
+    const trimmed = src.trim();
+    if (!trimmed)
+        return null;
+    if (/^(https?:|data:)/i.test(trimmed))
+        return null;
+    if (trimmed.startsWith(DOCS_MEDIA_SENTINEL_PREFIX)) {
+        return decodeDocsMediaSentinel(trimmed);
+    }
+    if (trimmed.startsWith("/"))
+        return null;
+    const notePath = normalizeSourcePath(sourcePath);
+    if (!notePath.startsWith(DOCS_ROOT_PREFIX))
+        return null;
+    const slash = notePath.lastIndexOf("/");
+    if (slash < 0)
+        return null;
+    const noteDir = notePath.slice(0, slash);
+    const resolved = resolvePosix(noteDir, trimmed);
+    if (!resolved || !resolved.startsWith(DOCS_ROOT_PREFIX))
+        return null;
+    return resolved.slice(DOCS_ROOT_PREFIX.length);
+}
+/**
+ * Rewrite a markdown image src for preview.
+ * By default emits the server API URL; pass `encodeDocsMediaSentinel` for
+ * deferred runtime resolution.
+ */
+export function rewriteDocsRelativeMediaSrc(src, sourcePath, resolveUrl = serverDocsMediaUrl) {
+    const trimmed = src.trim();
+    if (!trimmed)
+        return trimmed;
+    if (/^(https?:|data:)/i.test(trimmed))
+        return trimmed;
+    if (trimmed.startsWith("/") &&
+        !trimmed.startsWith(DOCS_MEDIA_SENTINEL_PREFIX)) {
+        return trimmed;
+    }
+    const relativePath = resolveDocsMediaRelativePath(trimmed, sourcePath);
+    if (!relativePath)
+        return trimmed;
+    const resolved = resolveUrl(relativePath);
+    if (typeof resolved !== "string") {
+        // Async resolvers must use the sentinel + post-render path.
+        return encodeDocsMediaSentinel(relativePath);
+    }
+    return resolved;
+}

package/dist/model/docs-review-constants.d.ts

@@ -0,0 +1,4 @@
+import type { DocsReviewRating } from './types';
+export declare const REVIEW_RATINGS: DocsReviewRating[];
+export declare const REVIEW_RATING_LABELS: Record<DocsReviewRating, string>;
+export declare const REVIEW_RATING_KEYS: Record<string, DocsReviewRating>;

package/dist/model/docs-review-constants.js

@@ -0,0 +1,13 @@
+export const REVIEW_RATINGS = ['again', 'hard', 'good', 'easy'];
+export const REVIEW_RATING_LABELS = {
+    again: 'Again',
+    hard: 'Hard',
+    good: 'Good',
+    easy: 'Easy'
+};
+export const REVIEW_RATING_KEYS = {
+    '1': 'again',
+    '2': 'hard',
+    '3': 'good',
+    '4': 'easy'
+};

package/dist/model/fsrs.d.ts

@@ -0,0 +1,14 @@
+import { type Card, type CardInput } from "ts-fsrs";
+import { type DocsCard, type DocsFsrsState, type DocsNote, type DocsReviewQueueItem, type DocsReviewRating } from "./types";
+export declare const docsFsrsParameters: import("ts-fsrs").FSRSParameters;
+export declare function fsrsStateFromCard(card: Card): DocsFsrsState;
+export declare function fsrsCardFromState(state: DocsFsrsState | undefined, now?: Date): CardInput | Card;
+export declare function reviewDocsCard(card: DocsCard, rating: DocsReviewRating, reviewedAt?: Date): DocsCard;
+export declare function buildDocsReviewQueue(notes: DocsNote[], now?: Date): DocsReviewQueueItem[];
+export declare function previewDocsCardRatings(card: DocsCard, now?: Date): {
+    again: DocsFsrsState;
+    hard: DocsFsrsState;
+    good: DocsFsrsState;
+    easy: DocsFsrsState;
+};
+export declare function formatDocsReviewInterval(due: string, now?: Date): string;

package/dist/model/fsrs.js

@@ -0,0 +1,153 @@
+import { Rating, State, createEmptyCard, fsrs, generatorParameters, } from "ts-fsrs";
+import {} from "./types";
+export const docsFsrsParameters = generatorParameters({
+    request_retention: 0.9,
+    enable_fuzz: true,
+    enable_short_term: true,
+    learning_steps: ["1m", "10m"],
+    relearning_steps: ["10m"],
+});
+const ratingMap = {
+    again: Rating.Again,
+    hard: Rating.Hard,
+    good: Rating.Good,
+    easy: Rating.Easy,
+};
+const ratingNameByValue = new Map([
+    [Rating.Again, "again"],
+    [Rating.Hard, "hard"],
+    [Rating.Good, "good"],
+    [Rating.Easy, "easy"],
+]);
+function stateName(value) {
+    return State[value];
+}
+function stateValue(value) {
+    return State[value];
+}
+function toDate(value) {
+    return value instanceof Date ? value : new Date(value);
+}
+function toIso(value) {
+    return toDate(value).toISOString();
+}
+export function fsrsStateFromCard(card) {
+    return {
+        due: toIso(card.due),
+        stability: card.stability,
+        difficulty: card.difficulty,
+        elapsedDays: card.elapsed_days,
+        scheduledDays: card.scheduled_days,
+        learningSteps: card.learning_steps,
+        reps: card.reps,
+        lapses: card.lapses,
+        state: stateName(card.state),
+        ...(card.last_review ? { lastReview: toIso(card.last_review) } : {}),
+    };
+}
+export function fsrsCardFromState(state, now = new Date()) {
+    if (!state)
+        return createEmptyCard(now);
+    return {
+        due: toDate(state.due),
+        stability: state.stability,
+        difficulty: state.difficulty,
+        elapsed_days: state.elapsedDays,
+        scheduled_days: state.scheduledDays,
+        learning_steps: state.learningSteps,
+        reps: state.reps,
+        lapses: state.lapses,
+        state: stateValue(state.state),
+        last_review: state.lastReview ? toDate(state.lastReview) : null,
+    };
+}
+function reviewLogId(cardId, review) {
+    const stamp = review
+        .toISOString()
+        .replace(/\.\d{3}Z$/, "Z")
+        .replace(/[^0-9TZ]+/g, "")
+        .replace(/Z$/, "")
+        .toLowerCase();
+    return `${cardId}-${stamp}`;
+}
+function docsReviewLog(cardId, log, fallbackRating) {
+    return {
+        id: reviewLogId(cardId, log.review),
+        rating: ratingNameByValue.get(log.rating) ?? fallbackRating,
+        reviewedAt: log.review.toISOString(),
+        state: stateName(log.state),
+        due: log.due.toISOString(),
+        stability: log.stability,
+        difficulty: log.difficulty,
+        elapsedDays: log.elapsed_days,
+        scheduledDays: log.scheduled_days,
+        learningSteps: log.learning_steps,
+    };
+}
+export function reviewDocsCard(card, rating, reviewedAt = new Date()) {
+    if (card.type === "coding")
+        throw new Error("Coding cards are evaluated through exercise submissions.");
+    const scheduler = fsrs(docsFsrsParameters);
+    const result = scheduler.next(fsrsCardFromState(card.fsrs, reviewedAt), reviewedAt, ratingMap[rating]);
+    return {
+        ...card,
+        fsrs: fsrsStateFromCard(result.card),
+        reviews: [...card.reviews, docsReviewLog(card.id, result.log, rating)],
+    };
+}
+function dueAt(card, now) {
+    return card.fsrs?.due ?? now.toISOString();
+}
+export function buildDocsReviewQueue(notes, now = new Date()) {
+    const nowMs = now.getTime();
+    return notes
+        .flatMap((note) => note.cards
+        .filter((card) => card.status === "active" && card.type !== "coding")
+        .map((card) => ({
+        noteId: note.id,
+        noteTitle: note.title,
+        noteSourcePath: note.sourcePath,
+        cardId: card.id,
+        card,
+        dueAt: dueAt(card, now),
+    })))
+        .filter((item) => new Date(item.dueAt).getTime() <= nowMs)
+        .sort((left, right) => {
+        const dueDiff = new Date(left.dueAt).getTime() - new Date(right.dueAt).getTime();
+        if (dueDiff !== 0)
+            return dueDiff;
+        return `${left.noteTitle}/${left.cardId}`.localeCompare(`${right.noteTitle}/${right.cardId}`);
+    });
+}
+export function previewDocsCardRatings(card, now = new Date()) {
+    const scheduler = fsrs(docsFsrsParameters);
+    const preview = scheduler.repeat(fsrsCardFromState(card.fsrs, now), now);
+    return {
+        again: fsrsStateFromCard(preview[Rating.Again].card),
+        hard: fsrsStateFromCard(preview[Rating.Hard].card),
+        good: fsrsStateFromCard(preview[Rating.Good].card),
+        easy: fsrsStateFromCard(preview[Rating.Easy].card),
+    };
+}
+function formatDateOnly(value) {
+    const year = value.getFullYear();
+    const month = String(value.getMonth() + 1).padStart(2, "0");
+    const day = String(value.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+export function formatDocsReviewInterval(due, now = new Date()) {
+    const dueDate = toDate(due);
+    const diffMs = dueDate.getTime() - now.getTime();
+    if (diffMs <= 0)
+        return "<1m";
+    const minutes = Math.round(diffMs / 60_000);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return `${hours}h`;
+    const days = Math.round(hours / 24);
+    if (days < 60)
+        return `${days}d`;
+    return formatDateOnly(dueDate);
+}

package/dist/model/graph.d.ts

@@ -0,0 +1,12 @@
+import { type DocsGraph, type DocsNote, type DocsWikiLink } from "./types";
+export declare function extractDocsWikiLinks(note: DocsNote): DocsWikiLink[];
+export declare function extractDocsTags(value: string): string[];
+export declare function normalizeDocsTag(tag: string): string;
+export declare function docsTagMatchesFolder(tag: string, folder: string): boolean;
+type DocsNoteTagSource = Pick<DocsNote, "tags" | "aliases"> & Partial<Pick<DocsNote, "cards" | "blocks" | "body" | "title" | "docType" | "summary" | "learningGoal">>;
+/** Note, card, and inline body tags used for folder membership and filtering. */
+export declare function docsNoteTagValues(note: DocsNoteTagSource): string[];
+export declare function docsNoteMatchesTagFolder(note: DocsNoteTagSource, folder: string): boolean;
+export declare function resolveDocsNoteId(notes: Array<Pick<DocsNote, "id" | "title" | "aliases">>, target: string | null | undefined): string | null;
+export declare function buildDocsGraph(notes: DocsNote[]): DocsGraph;
+export {};