@minamocms/framework 0.0.0-stage → 0.10.2

package/dist/services/delete-content.js

@@ -0,0 +1,166 @@
+import { existsSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { listFilesRecursively } from "./fs-walk.js";
+import { commitPaths } from "./git.js";
+import { sanitisePath } from "./path-safety.js";
+import { RedirectError, addRedirect, isValidRedirectTarget, loadRedirects, serialiseRedirects, } from "./redirects.js";
+import { pagePathToUrl } from "./urls.js";
+import { enqueue } from "./write-queue.js";
+import { reindexInBackground } from "./reindex-on-write.js";
+const PAGES_PREFIX = 'pages/';
+// Returns null for anything else (menus have no public URL at all, so
+// redirects are meaningless there).
+function urlForDeletedEntry(relativePath) {
+    if (relativePath.startsWith(PAGES_PREFIX)) {
+        return pagePathToUrl(relativePath.slice(PAGES_PREFIX.length));
+    }
+    return null;
+}
+export class DeleteContentError extends Error {
+    reason;
+    constructor(reason, message, options) {
+        super(message, options);
+        this.name = 'DeleteContentError';
+        this.reason = reason;
+    }
+}
+// Validates and writes everything a delete needs, stopping short of
+// the commit itself - used both by the standalone deleteContentJob
+// (which commits immediately after) and by batch.ts (which accumulates
+// this alongside other operations and commits once for the whole
+// batch). A write-phase failure (including a client-triggered
+// redirect-cycle) is caught and rolled back here, inside prepare
+// itself, so prepare either fully succeeds or fully undoes itself
+// before throwing.
+export function prepareDeleteContent(config, relativePath, redirectTo) {
+    const livePath = sanitisePath(config.contentRoot, relativePath);
+    if (!existsSync(livePath)) {
+        throw new DeleteContentError('page-not-found', `No live page found at "${relativePath}"`);
+    }
+    // Subtree rejection: a deliberate scope decision (reject outright,
+    // not cascade) - an accidental single DELETE can't silently take a
+    // whole subtree with it. "Has children" means a real child page
+    // exists (checked via listFilesRecursively), never bare directory
+    // existence: a leftover *empty* sibling directory would otherwise
+    // make this page permanently undeletable, since no rmdir/cleanup
+    // endpoint exists anywhere in this API to ever clear it.
+    if (relativePath.startsWith(PAGES_PREFIX)) {
+        const dirRelative = relativePath.slice(PAGES_PREFIX.length).replace(/\.json$/, '');
+        const dirPath = sanitisePath(config.pagesRoot, dirRelative);
+        if (existsSync(dirPath) &&
+            statSync(dirPath).isDirectory() &&
+            listFilesRecursively(dirPath, dirPath, '.json').length > 0) {
+            throw new DeleteContentError('has-children', `"${relativePath}" has child pages; delete them first`);
+        }
+    }
+    // Never touches a draft at the same path: /v1/content and /v1/drafts
+    // are separate resources with their own dedicated DELETEs, and a
+    // draft-only page is already a legitimate, independently-listable
+    // state (Group D's listContent unions contentRoot/draftsRoot).
+    const original = readFileSync(livePath);
+    let redirectsBefore = null;
+    let redirectsChanged = false;
+    // Reverses the unlink and restores/removes redirects.json. Matches
+    // publish.ts's/move.ts's rollback() philosophy: attempt everything,
+    // report every failure.
+    function undoDeleteWrites() {
+        const restoreFailures = [];
+        try {
+            writeFileSync(livePath, original);
+        }
+        catch (restoreError) {
+            restoreFailures.push(restoreError);
+        }
+        if (redirectsChanged) {
+            try {
+                if (redirectsBefore === null) {
+                    rmSync(config.redirectsPath, { force: true });
+                }
+                else {
+                    writeFileSync(config.redirectsPath, redirectsBefore);
+                }
+            }
+            catch (restoreError) {
+                restoreFailures.push(restoreError);
+            }
+        }
+        return restoreFailures;
+    }
+    try {
+        unlinkSync(livePath);
+        // redirectTo is client-supplied, unlike publish.ts/move.ts's own
+        // automatic redirect bookkeeping - a client can trivially trigger a
+        // real cycle (e.g. redirectTo pointing back into an existing
+        // chain), so that's surfaced as its own reason, not left to fall
+        // into the generic write-failed/500 bucket an unlikely automatic-
+        // bookkeeping cycle would. Format is validated the same way as the
+        // dedicated manage-redirects.ts endpoints, internal-paths-only,
+        // so the two write paths never disagree on what's allowed into
+        // redirects.json.
+        const fromUrl = urlForDeletedEntry(relativePath);
+        if (redirectTo !== undefined && fromUrl !== null) {
+            if (!isValidRedirectTarget(redirectTo)) {
+                throw new DeleteContentError('invalid-redirect-target', `redirectTo "${redirectTo}" must be an internal path starting with "/"`);
+            }
+            redirectsBefore = existsSync(config.redirectsPath)
+                ? readFileSync(config.redirectsPath, 'utf-8')
+                : null;
+            let entries;
+            try {
+                entries = addRedirect(loadRedirects(config).entries, fromUrl, redirectTo).entries;
+            }
+            catch (error) {
+                if (error instanceof RedirectError) {
+                    throw new DeleteContentError('redirect-cycle', error.message, { cause: error });
+                }
+                throw error;
+            }
+            const serialised = serialiseRedirects(entries);
+            if (serialised !== (redirectsBefore ?? '')) {
+                writeFileSync(config.redirectsPath, serialised);
+                redirectsChanged = true;
+            }
+        }
+    }
+    catch (error) {
+        const failures = undoDeleteWrites();
+        if (failures.length > 0) {
+            throw new DeleteContentError('rollback-failed', 'Delete failed and rolling back afterwards also failed; the working tree may be inconsistent and needs manual inspection', { cause: error });
+        }
+        // A redirect-cycle is already a DeleteContentError with its own
+        // reason - preserve it rather than reclassifying it as write-failed.
+        if (error instanceof DeleteContentError) {
+            throw error;
+        }
+        // Always write-failed here, structurally: commitPaths hasn't been
+        // called yet, so this can never be a GitOperationError.
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new DeleteContentError('write-failed', `Delete failed: ${detail}`, { cause: error });
+    }
+    const paths = [livePath];
+    if (redirectsChanged) {
+        paths.push(config.redirectsPath);
+    }
+    return { paths, undo: undoDeleteWrites };
+}
+async function deleteContentJob(config, relativePath, redirectTo, message, author) {
+    const { paths, undo } = prepareDeleteContent(config, relativePath, redirectTo);
+    try {
+        commitPaths(config.siteRoot, paths, message, author);
+    }
+    catch (error) {
+        const failures = undo();
+        if (failures.length > 0) {
+            throw new DeleteContentError('rollback-failed', 'Delete failed and rolling back afterwards also failed; the working tree may be inconsistent and needs manual inspection', { cause: error });
+        }
+        // Always commit-failed here, structurally: prepare already
+        // succeeded, so anything caught in this try can only have come
+        // from commitPaths itself.
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new DeleteContentError('commit-failed', `Delete failed: ${detail}`, { cause: error });
+    }
+}
+export function deleteContent(config, relativePath, redirectTo, message, author) {
+    const result = enqueue(() => deleteContentJob(config, relativePath, redirectTo, message, author));
+    result.then(() => reindexInBackground(config), () => undefined);
+    return result;
+}

package/dist/services/deleted-pages.d.ts

@@ -0,0 +1,11 @@
+import type { SiteConfig } from '../config.ts';
+export interface DeletedPage {
+    path: string;
+    url: string;
+    name: string;
+    title: string;
+    deletedAt: string;
+    deletedBy: string;
+    ref: string;
+}
+export declare function listDeletedPages(config: SiteConfig, limit?: number): DeletedPage[];

package/dist/services/deleted-pages.js

@@ -0,0 +1,83 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFileAtRevision } from "./git-history.js";
+import { sanitisePath } from "./path-safety.js";
+import { pagePathToUrl } from "./urls.js";
+const FIELD_SEP = '\x1f';
+const RECORD_SEP = '\x1e';
+const DEFAULT_LIMIT = 50;
+// How far back "recently" reaches (agreed with the owner). Older deletions
+// can still be restored from git; they just aren't listed.
+const RECENT_DAYS = 90;
+function hasCommits(config) {
+    try {
+        execFileSync('git', ['rev-parse', '--verify', '--quiet', 'HEAD'], { cwd: config.siteRoot, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function existsNow(config, path) {
+    try {
+        return existsSync(sanitisePath(config.contentRoot, path)) || (existsSync(config.draftsRoot) && existsSync(sanitisePath(config.draftsRoot, path)));
+    }
+    catch {
+        return false;
+    }
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : null;
+}
+// The page's name and title as they were at ref, each falling back to
+// the other (and to its address) when missing.
+function labelsAt(config, ref, path, url) {
+    let name = null;
+    let title = null;
+    try {
+        const page = JSON.parse(readFileAtRevision(config, ref, `content/${path}`).toString('utf-8'));
+        name = nonEmpty(page.name);
+        title = nonEmpty(page.title);
+    }
+    catch {
+        // Unreadable at ref: fall back to the address.
+    }
+    return { name: name ?? title ?? url, title: title ?? name ?? url };
+}
+export function listDeletedPages(config, limit = DEFAULT_LIMIT) {
+    if (!hasCommits(config)) {
+        return [];
+    }
+    const raw = execFileSync('git', ['log', `--since=${RECENT_DAYS} days ago`, '--diff-filter=D', '--name-only', `--format=${RECORD_SEP}%P${FIELD_SEP}%an${FIELD_SEP}%aI`, '--', 'content/pages'], { cwd: config.siteRoot, maxBuffer: 32 * 1024 * 1024 }).toString('utf-8');
+    const seen = new Set();
+    const deleted = [];
+    for (const record of raw.split(RECORD_SEP)) {
+        const [header, ...files] = record.split('\n');
+        // %P: the deleting commit's parent - the last version with the page.
+        // A full commit id, since refs like "abc^" aren't accepted.
+        const [parents, author, date] = (header ?? '').split(FIELD_SEP);
+        const parent = parents?.split(' ')[0];
+        if (!parent || !author || !date) {
+            continue;
+        }
+        for (const file of files) {
+            const path = file.trim().replace(/^content\//, '');
+            if (!/^pages\/.+\.json$/.test(path) || seen.has(path)) {
+                continue;
+            }
+            // Most recent deletion first: an older one of the same path is
+            // history, not something to restore.
+            seen.add(path);
+            if (existsNow(config, path)) {
+                continue;
+            }
+            const ref = parent;
+            const url = pagePathToUrl(path.slice('pages/'.length));
+            deleted.push({ path, url, ...labelsAt(config, ref, path, url), deletedAt: date, deletedBy: author, ref });
+            if (deleted.length >= limit) {
+                return deleted;
+            }
+        }
+    }
+    return deleted;
+}

package/dist/services/dev-tunnel.d.ts

@@ -0,0 +1,5 @@
+export interface DevTunnel {
+    url: string;
+    close: () => void;
+}
+export declare function startDevTunnel(port: number): Promise<DevTunnel>;

package/dist/services/dev-tunnel.js

@@ -0,0 +1,5 @@
+import localtunnel from 'localtunnel';
+export async function startDevTunnel(port) {
+    const tunnel = await localtunnel({ port });
+    return { url: tunnel.url, close: () => tunnel.close() };
+}

package/dist/services/drafts.d.ts

@@ -0,0 +1,16 @@
+import type { SiteConfig } from '../config.ts';
+import type { PreparedOperation } from './prepared-operation.ts';
+import type { ThemeSchemas, ValidationError } from './validation.ts';
+export declare function ensureDraftsRoot(config: SiteConfig): void;
+export type DraftReason = 'validation-failed' | 'conflict';
+export declare class DraftError extends Error {
+    readonly reason: DraftReason;
+    readonly errors: ValidationError[];
+    constructor(reason: DraftReason, message: string, errors?: ValidationError[]);
+}
+export declare function saveDraft(config: SiteConfig, themeSchemas: ThemeSchemas, relativePath: string, content: unknown, expectedEtag: string): Promise<string>;
+export declare function discardDraft(config: SiteConfig, relativePath: string): Promise<void>;
+export declare function prepareSaveDraft(config: SiteConfig, themeSchemas: ThemeSchemas, relativePath: string, content: unknown, expectedEtag: string): Promise<PreparedOperation & {
+    etag: string;
+}>;
+export declare function prepareDiscardDraft(config: SiteConfig, relativePath: string): Promise<PreparedOperation>;

package/dist/services/drafts.js

@@ -0,0 +1,164 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { ContentReadError, readContentFile } from "./content-read.js";
+import { computeEtag, etagsMatch } from "./etag.js";
+import { sanitisePath } from "./path-safety.js";
+import { validateContent } from "./validation.js";
+import { enqueue } from "./write-queue.js";
+// content/drafts/ may not exist: git keeps no empty folders, so a site
+// cloned or deployed with no drafts has none. Every draft read and write
+// resolves its path under this folder (sanitisePath needs the root to
+// exist), so without it the first draft save failed with a 500 - found
+// running a fresh clone of a real site. Made once at start-up, before any
+// request, rather than on every write.
+export function ensureDraftsRoot(config) {
+    mkdirSync(config.draftsRoot, { recursive: true });
+}
+export class DraftError extends Error {
+    reason;
+    // Group I: the real ajv errors (already field-pointing, e.g.
+    // /sections/0/settings/columns) - previously only available
+    // stringified inside .message. Always [] for the 'conflict' reason.
+    errors;
+    constructor(reason, message, errors = []) {
+        super(message);
+        this.name = 'DraftError';
+        this.reason = reason;
+        this.errors = errors;
+    }
+}
+// Draft takes precedence over live: the ETag a client's If-Match must
+// match is whatever they would have read from a prior GET, and D1/D2
+// already prefer the draft over the live file at the same path. Reuses
+// readContentFile/computeEtag (etag.ts's own doc comment anticipates
+// this exact reuse) rather than reimplementing hashing here. Returns
+// null when neither a draft nor a live file exists yet (a brand-new
+// page) - see saveDraftJob's own comment for what that means.
+function readCurrentEtag(config, relativePath) {
+    try {
+        return readContentFile(config.draftsRoot, relativePath).etag;
+    }
+    catch (error) {
+        if (!(error instanceof ContentReadError) || error.reason !== 'not-found') {
+            throw error;
+        }
+    }
+    try {
+        return readContentFile(config.contentRoot, relativePath).etag;
+    }
+    catch (error) {
+        if (!(error instanceof ContentReadError) || error.reason !== 'not-found') {
+            throw error;
+        }
+        return null;
+    }
+}
+async function saveDraftJob(config, themeSchemas, relativePath, content, expectedEtag) {
+    const draftPath = sanitisePath(config.draftsRoot, relativePath);
+    // The If-Match check happens here, inside the queued job, never at
+    // the route layer before enqueuing: the queue only serialises the
+    // writes themselves, not a check that happened earlier, so a
+    // route-layer check-then-enqueue has a real TOCTOU gap (verified
+    // empirically: run 2000 times, a check-before-enqueue design lets
+    // both of two racing requests succeed every single time; the same
+    // check run inside the job, like this, produced exactly one winner
+    // every time, no exceptions).
+    const currentEtag = readCurrentEtag(config, relativePath);
+    if (currentEtag !== null && !etagsMatch(currentEtag, expectedEtag)) {
+        throw new DraftError('conflict', `If-Match "${expectedEtag}" does not match the current ETag for "${relativePath}"`);
+    }
+    // currentEtag === null means neither a draft nor a live file exists
+    // yet (a brand-new page) - deliberately not checked further here.
+    // This isn't a race loophole: the *next* write to this same path
+    // lands after this job's write has created a real draft, so that
+    // job's own currentEtag is no longer null and gets checked for
+    // real. Only the very first write to a wholly new path skips the
+    // comparison, and nothing (E1-E6) tests or specifies what that first
+    // write's If-Match value should mean.
+    // Validate before touching disk at all, so a validation failure
+    // writes nothing (checklist C3) structurally, not via cleanup.
+    const result = validateContent(relativePath, content, themeSchemas);
+    if (!result.valid) {
+        throw new DraftError('validation-failed', `Draft at "${relativePath}" failed validation: ${JSON.stringify(result.errors)}`, result.errors);
+    }
+    mkdirSync(dirname(draftPath), { recursive: true });
+    const bytes = Buffer.from(JSON.stringify(content, null, 2));
+    writeFileSync(draftPath, bytes);
+    // No git call: saves are cheap and frequent, and never create history
+    // (checklist C2, constraint 5).
+    // Computed from the exact bytes just written, never a second disk
+    // read (inside or outside the queue) - a second read could itself
+    // race a subsequent queued job and hand the client a stale value.
+    return computeEtag(bytes);
+}
+async function discardDraftJob(config, relativePath) {
+    const draftPath = sanitisePath(config.draftsRoot, relativePath);
+    // Idempotent, matching DELETE semantics: silently succeed if the
+    // draft is already absent rather than inventing a not-found error
+    // the checklist doesn't ask for.
+    if (existsSync(draftPath)) {
+        unlinkSync(draftPath);
+    }
+    // No git call: discard never touches /content/ or history.
+}
+export function saveDraft(config, themeSchemas, relativePath, content, expectedEtag) {
+    return enqueue(() => saveDraftJob(config, themeSchemas, relativePath, content, expectedEtag));
+}
+export function discardDraft(config, relativePath) {
+    return enqueue(() => discardDraftJob(config, relativePath));
+}
+// The batch.ts-composable shape, mirroring publish.ts/move.ts/
+// delete-content.ts's own prepare* exports for a single uniform
+// vocabulary - even though saveDraftJob/discardDraftJob never call
+// commitPaths at all (drafts are never git-tracked, so paths is
+// always []), batch.ts still needs an undo for them: F6 requires "no
+// partial writes" for a whole failed batch, which includes rolling
+// back an earlier draft write if a later operation in the same batch
+// fails. Snapshots the draft's prior bytes/existence *before*
+// delegating to the existing job function, rather than reimplementing
+// its logic here.
+export async function prepareSaveDraft(config, themeSchemas, relativePath, content, expectedEtag) {
+    const draftPath = sanitisePath(config.draftsRoot, relativePath);
+    const existedBefore = existsSync(draftPath);
+    const originalBytes = existedBefore ? readFileSync(draftPath) : null;
+    const etag = await saveDraftJob(config, themeSchemas, relativePath, content, expectedEtag);
+    return {
+        paths: [],
+        etag,
+        undo: () => {
+            try {
+                if (existedBefore) {
+                    writeFileSync(draftPath, originalBytes);
+                }
+                else {
+                    unlinkSync(draftPath);
+                }
+                return [];
+            }
+            catch (error) {
+                return [error];
+            }
+        },
+    };
+}
+export async function prepareDiscardDraft(config, relativePath) {
+    const draftPath = sanitisePath(config.draftsRoot, relativePath);
+    const existedBefore = existsSync(draftPath);
+    const originalBytes = existedBefore ? readFileSync(draftPath) : null;
+    await discardDraftJob(config, relativePath);
+    return {
+        paths: [],
+        undo: () => {
+            try {
+                if (existedBefore) {
+                    mkdirSync(dirname(draftPath), { recursive: true });
+                    writeFileSync(draftPath, originalBytes);
+                }
+                return [];
+            }
+            catch (error) {
+                return [error];
+            }
+        },
+    };
+}

package/dist/services/etag.d.ts

@@ -0,0 +1,2 @@
+export declare function computeEtag(bytes: Buffer): string;
+export declare function etagsMatch(a: string, b: string): boolean;

package/dist/services/etag.js

@@ -0,0 +1,30 @@
+import { createHash } from 'node:crypto';
+// A plain content hash, not a git blob hash: git.ts only shells out to
+// git for actual commits, never for a per-request read, and nothing
+// downstream needs the ETag to coincide with a real git blob hash
+// (the git log/show endpoints address content by ref+path, not by
+// hash lookup). A quoted strong ETag, matching HTTP's own syntax -
+// this is a byte-for-byte digest, so strong semantics are correct.
+//
+// The one hash function every ETag-producing read (D1/D2) and every
+// future If-Match comparison (Group E) must share - never inlined
+// separately, or the two could silently drift.
+export function computeEtag(bytes) {
+    return `"${createHash('sha256').update(bytes).digest('hex')}"`;
+}
+// RFC 7232 weak comparison: a compressing proxy sitting in front of a
+// real deployment (confirmed live against a Railway-hosted admin - its
+// edge downgrades this server's own strong ETag to weak in transit,
+// since the compressed bytes on the wire differ from what computeEtag
+// hashed) is standard, spec-compliant proxy behaviour, not a bug on
+// the proxy's part. A client that captured and echoes back that
+// now-weak value represents the exact same content a strict `===`
+// would wrongly reject as changed - every If-Match check must compare
+// this way, never with a bare `!==`, or any real host behind a
+// compressing proxy/CDN produces spurious conflicts on every save.
+function stripWeakPrefix(etag) {
+    return etag.startsWith('W/') ? etag.slice(2) : etag;
+}
+export function etagsMatch(a, b) {
+    return stripWeakPrefix(a) === stripWeakPrefix(b);
+}

package/dist/services/fs-walk.d.ts

@@ -0,0 +1 @@
+export declare function listFilesRecursively(dir: string, base: string, extension: string): string[];

package/dist/services/fs-walk.js

@@ -0,0 +1,26 @@
+import { readdirSync } from 'node:fs';
+import { join, relative } from 'node:path';
+// Recursively lists files matching extension under dir, returned as
+// paths relative to base. Agent-configured roots only (content/drafts
+// roots, theme directories), never a request-supplied :path - callers
+// that walk request-shaped paths must go through sanitisePath instead.
+export function listFilesRecursively(dir, base, extension) {
+    let out = [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out = out.concat(listFilesRecursively(full, base, extension));
+        }
+        else if (entry.isFile() && entry.name.endsWith(extension)) {
+            out.push(relative(base, full));
+        }
+    }
+    return out;
+}

package/dist/services/git-commit.d.ts

@@ -0,0 +1,3 @@
+import type { SiteConfig } from '../config.ts';
+import type { CommitAuthor } from './git.ts';
+export declare function commitWorkingTreeChanges(config: SiteConfig, message: string, author: CommitAuthor): Promise<'committed' | 'clean'>;

package/dist/services/git-commit.js

@@ -0,0 +1,12 @@
+import { commitWorkingTree } from "./git.js";
+import { enqueue } from "./write-queue.js";
+// The escape hatch (checklist G5). No PreparedOperation/undo-stack
+// here, unlike publish/move/delete/revert: those services write new
+// content themselves on request, so a write can fail independently of
+// the git step, needing an undo. Here the "write" already exists in
+// the working tree before this is ever called - the only failure
+// modes are git add/git commit themselves, which commitWorkingTree's
+// own bare `git reset` already unwinds (git.ts).
+export function commitWorkingTreeChanges(config, message, author) {
+    return enqueue(() => Promise.resolve(commitWorkingTree(config.siteRoot, message, author)));
+}

package/dist/services/git-history.d.ts

@@ -0,0 +1,28 @@
+import type { SiteConfig } from '../config.ts';
+export interface LogEntry {
+    hash: string;
+    author: {
+        name: string;
+        email: string;
+    };
+    date: string;
+    message: string;
+    isCheckpoint: boolean;
+}
+export interface LogResult {
+    commits: LogEntry[];
+    hasMore: boolean;
+}
+export declare const CHECKPOINT_MESSAGE = "chore: draft checkpoint";
+export declare function getCommitLog(config: SiteConfig, options: {
+    path?: string;
+    limit?: number;
+}): LogResult;
+export type GitShowReason = 'invalid-ref' | 'not-found-at-ref';
+export declare class GitShowError extends Error {
+    readonly reason: GitShowReason;
+    constructor(reason: GitShowReason, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function readFileAtRevision(config: SiteConfig, ref: string, relativePath: string): Buffer;