vestrycms 0.0.0-stage → 0.1.0

package/dist/core/auth.js

@@ -0,0 +1,234 @@
+/**
+ * Sign-in and users, on Better Auth. Editors sign in with a one-time code
+ * emailed to them (the email OTP plugin); admins manage users through the
+ * admin plugin. Vestry adds: config-listed bootstrap admins, invitations,
+ * and a `lastLoginAt` field.
+ *
+ * Storage is whatever Better Auth accepts: a Cloudflare D1 binding in
+ * production, a `node:sqlite` database in development, the memory adapter
+ * in tests. Tables are created on first use with Better Auth's migrator.
+ */
+import { betterAuth } from "better-auth";
+import { createAuthMiddleware } from "better-auth/api";
+import { getMigrations } from "better-auth/db/migration";
+import { admin, emailOTP } from "better-auth/plugins";
+import { createAccessControl } from "better-auth/plugins/access";
+import { defaultStatements } from "better-auth/plugins/admin/access";
+import { isRole } from "./roles.js";
+/** Vestry's two roles in Better Auth's access-control terms: admins manage users, editors don't. */
+const ac = createAccessControl(defaultStatements);
+const roles = {
+    // Only what the Users page needs: no impersonation, bans or passwords.
+    admin: ac.newRole({
+        user: ["create", "list", "get", "update", "set-role", "delete"],
+    }),
+    editor: ac.newRole({ user: [] }),
+};
+export const SESSION_TTL_SECONDS = 60 * 60 * 24 * 30;
+export const CODE_TTL_SECONDS = 10 * 60;
+const CODE_TTL_MINUTES = Math.round(CODE_TTL_SECONDS / 60);
+export function normalizeEmail(email) {
+    return email.trim().toLowerCase();
+}
+/** Display name fallback: the part before the `@`, title-cased a little. */
+export function nameFromEmail(email) {
+    const local = email.split("@")[0] ?? email;
+    const pretty = local
+        .split(/[._-]+/)
+        .filter(Boolean)
+        .map((p) => p[0].toUpperCase() + p.slice(1))
+        .join(" ");
+    // Commit authors need a non-empty name; fall back to the address itself.
+    return pretty || local || email;
+}
+/**
+ * Migrations run once per database per isolate, whichever origin asked
+ * first (the instances per origin share the database).
+ */
+const migratedByDatabase = new WeakMap();
+export function createVestryAuth(opts) {
+    const admins = (opts.admins ?? []).map(normalizeEmail);
+    const isConfigAdmin = (email) => admins.includes(normalizeEmail(email));
+    const auth = betterAuth({
+        appName: opts.siteName,
+        secret: opts.secret,
+        baseURL: opts.baseURL,
+        basePath: opts.basePath,
+        database: opts.database,
+        session: {
+            expiresIn: SESSION_TTL_SECONDS,
+            updateAge: 60 * 60 * 24,
+        },
+        rateLimit: {
+            enabled: !opts.dev,
+            storage: "database",
+        },
+        advanced: {
+            cookiePrefix: "vestry",
+            useSecureCookies: opts.baseURL.startsWith("https://"),
+            defaultCookieAttributes: { path: opts.cookiePath ?? "/" },
+            // Cloudflare puts the client address in cf-connecting-ip; the default
+            // x-forwarded-for is absent or client-controlled there, which would
+            // collapse the rate limiter into one shared bucket.
+            ipAddress: {
+                ipAddressHeaders: ["cf-connecting-ip", "x-forwarded-for"],
+            },
+        },
+        user: {
+            additionalFields: {
+                lastLoginAt: { type: "date", required: false, input: false },
+            },
+        },
+        databaseHooks: {
+            session: {
+                create: {
+                    after: async (session, ctx) => {
+                        if (!ctx)
+                            return;
+                        if (session.impersonatedBy)
+                            return;
+                        await ctx.context.internalAdapter.updateUser(session.userId, {
+                            lastLoginAt: new Date(),
+                        });
+                    },
+                },
+            },
+        },
+        hooks: {
+            // The first admin has nobody to invite them. Addresses listed in the
+            // config are created on their first sign-in attempt, so the OTP plugin
+            // (which refuses unknown addresses) finds them.
+            before: createAuthMiddleware(async (ctx) => {
+                if (ctx.path !== "/email-otp/send-verification-otp")
+                    return;
+                const email = normalizeEmail(String(ctx.body?.email ?? ""));
+                if (!isConfigAdmin(email))
+                    return;
+                const existing = await ctx.context.internalAdapter.findUserByEmail(email);
+                if (existing) {
+                    const role = existing.user.role;
+                    if (role !== "admin") {
+                        await ctx.context.internalAdapter.updateUser(existing.user.id, {
+                            role: "admin",
+                        });
+                    }
+                    return;
+                }
+                await ctx.context.internalAdapter.createUser({
+                    email,
+                    name: nameFromEmail(email),
+                    emailVerified: false,
+                    role: "admin",
+                }, { method: "email-otp" });
+            }),
+        },
+        plugins: [
+            emailOTP({
+                otpLength: 6,
+                expiresIn: CODE_TTL_SECONDS,
+                allowedAttempts: 5,
+                // Encrypted with the secret, so a database dump alone can't be
+                // brute-forced against a six-digit code.
+                storeOTP: "encrypted",
+                // Only existing users (and config admins, created above) may sign in.
+                disableSignUp: true,
+                async sendVerificationOTP({ email, otp, type }) {
+                    if (type !== "sign-in")
+                        return;
+                    await opts.mailer.send({
+                        to: email,
+                        ...loginCodeEmail(opts.siteName, otp),
+                    });
+                },
+            }),
+            admin({
+                ac,
+                roles,
+                defaultRole: "editor",
+                adminRoles: ["admin"],
+            }),
+        ],
+    });
+    const ensureMigrated = () => {
+        if (opts.migrate === false)
+            return Promise.resolve();
+        const key = opts.database;
+        const pending = migratedByDatabase.get(key);
+        if (pending)
+            return pending;
+        const run = (async () => {
+            const { runMigrations, unsafeChanges } = await getMigrations(auth.options, { throwOnUnsafe: false });
+            for (const change of unsafeChanges ?? []) {
+                console.warn(`[vestry] auth schema needs a manual migration: ${change}`);
+            }
+            try {
+                await runMigrations();
+            }
+            catch (e) {
+                // Another isolate created the same table or index a moment earlier.
+                if (!/already exists/i.test(e instanceof Error ? e.message : String(e)))
+                    throw e;
+            }
+        })().catch((e) => {
+            migratedByDatabase.delete(key);
+            throw e;
+        });
+        migratedByDatabase.set(key, run);
+        return run;
+    };
+    /** The `PublicUser` view of a Better Auth user record. */
+    const toPublicUser = (user) => ({
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: isRole(user.role) ? user.role : "editor",
+        // Better Auth marks the address verified on the first successful code.
+        status: user.emailVerified ? "active" : "invited",
+        origin: isConfigAdmin(user.email) ? "config" : "invite",
+        createdAt: toIso(user.createdAt),
+        ...(user.lastLoginAt ? { lastLoginAt: toIso(user.lastLoginAt) } : {}),
+    });
+    const sendInvite = (by, user) => opts.mailer.send({
+        to: user.email,
+        ...inviteEmail(opts.siteName, opts.adminUrl, by.name, user),
+    });
+    return { auth, ensureMigrated, toPublicUser, isConfigAdmin, sendInvite };
+}
+function toIso(value) {
+    return value instanceof Date ? value.toISOString() : String(value);
+}
+// ------------------------------------------------------------------ emails
+function loginCodeEmail(siteName, code) {
+    const pretty = `${code.slice(0, 3)} ${code.slice(3)}`;
+    return {
+        subject: `${code} is your ${siteName} sign-in code`,
+        text: [
+            `Your sign-in code for ${siteName} is:`,
+            "",
+            `    ${pretty}`,
+            "",
+            `It expires in ${CODE_TTL_MINUTES} minutes. If you didn't request it, you can ignore this email.`,
+        ].join("\n"),
+        html: emailHtml(`Your sign-in code for <strong>${escapeHtml(siteName)}</strong> is:`, `<p style="font-size:32px;letter-spacing:6px;font-weight:700;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;margin:20px 0">${escapeHtml(pretty)}</p>`, `It expires in ${CODE_TTL_MINUTES} minutes. If you didn't request it, you can ignore this email.`),
+    };
+}
+function inviteEmail(siteName, adminUrl, inviterName, user) {
+    return {
+        subject: `You've been invited to edit ${siteName}`,
+        text: [
+            `${inviterName} invited you to edit ${siteName} as ${roleLabel(user.role)}.`,
+            "",
+            `Sign in at ${adminUrl} with this email address (${user.email}). We'll email you a code each time you sign in; there's no password.`,
+        ].join("\n"),
+        html: emailHtml(`${escapeHtml(inviterName)} invited you to edit <strong>${escapeHtml(siteName)}</strong> as ${roleLabel(user.role)}.`, `<p style="margin:20px 0"><a href="${escapeHtml(adminUrl)}" style="display:inline-block;background:#2563eb;color:#fff;text-decoration:none;padding:10px 18px;border-radius:8px;font-weight:600">Open ${escapeHtml(siteName)}</a></p>`, `Sign in with this email address (${escapeHtml(user.email)}). We'll email you a code each time you sign in; there's no password.`),
+    };
+}
+function roleLabel(role) {
+    return role === "admin" ? "an admin" : "an editor";
+}
+function emailHtml(lead, middle, trailer) {
+    return `<!doctype html><html><body style="margin:0;padding:24px;background:#f4f5f7;font-family:-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;color:#1f2937"><div style="max-width:480px;margin:0 auto;background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:28px 32px"><p style="margin:0 0 4px;font-size:16px">${lead}</p>${middle}<p style="margin:0;color:#6b7280;font-size:14px">${trailer}</p></div></body></html>`;
+}
+function escapeHtml(s) {
+    return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+}

package/dist/core/cache.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A tiny cache abstraction so the GitHub source can be snappy. The default is
+ * an in-memory LRU with TTLs; hosts can plug in something durable (e.g. a
+ * Cloudflare KV namespace) by implementing the same three methods.
+ */
+export interface Cache {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export declare class MemoryCache implements Cache {
+    #private;
+    private maxEntries;
+    constructor(maxEntries?: number);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/** Adapter for a Cloudflare KV-style namespace (`get`/`put`/`delete` with JSON). */
+export declare function kvCache(namespace: {
+    get(key: string, type: "json"): Promise<unknown>;
+    put(key: string, value: string, opts?: {
+        expirationTtl?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+}): Cache;
+export declare function sharedMemoryCache(): MemoryCache;

package/dist/core/cache.js

@@ -0,0 +1,52 @@
+export class MemoryCache {
+    maxEntries;
+    #map = new Map();
+    constructor(maxEntries = 2000) {
+        this.maxEntries = maxEntries;
+    }
+    async get(key) {
+        const e = this.#map.get(key);
+        if (!e)
+            return undefined;
+        if (e.expires !== null && e.expires < Date.now()) {
+            this.#map.delete(key);
+            return undefined;
+        }
+        // LRU bump
+        this.#map.delete(key);
+        this.#map.set(key, e);
+        return e.value;
+    }
+    async set(key, value, ttlSeconds) {
+        if (this.#map.size >= this.maxEntries) {
+            const oldest = this.#map.keys().next().value;
+            if (oldest !== undefined)
+                this.#map.delete(oldest);
+        }
+        this.#map.set(key, {
+            value,
+            expires: ttlSeconds ? Date.now() + ttlSeconds * 1000 : null,
+        });
+    }
+    async delete(key) {
+        this.#map.delete(key);
+    }
+}
+/** Adapter for a Cloudflare KV-style namespace (`get`/`put`/`delete` with JSON). */
+export function kvCache(namespace) {
+    return {
+        async get(key) {
+            return ((await namespace.get(key, "json")) ?? undefined);
+        },
+        async set(key, value, ttlSeconds) {
+            await namespace.put(key, JSON.stringify(value), ttlSeconds ? { expirationTtl: Math.max(60, ttlSeconds) } : undefined);
+        },
+        async delete(key) {
+            await namespace.delete(key);
+        },
+    };
+}
+let shared;
+export function sharedMemoryCache() {
+    return (shared ??= new MemoryCache());
+}

package/dist/core/entries.d.ts

@@ -0,0 +1,19 @@
+import type { EntryFormat } from "../config/types.js";
+export interface ParsedEntry {
+    data: Record<string, unknown>;
+    body: string;
+}
+/** Split a Markdown/MDX file into YAML frontmatter and body. */
+export declare function splitFrontmatter(text: string): {
+    data: Record<string, unknown>;
+    body: string;
+    hasFrontmatter: boolean;
+};
+export declare function parseEntry(format: EntryFormat, text: string): ParsedEntry;
+export declare function needsYamlQuotes(value: string): boolean;
+export declare function stringifyFrontmatter(data: Record<string, unknown>): string;
+export declare function serializeEntry(format: EntryFormat, entry: ParsedEntry): string;
+/** Single-file collections hold an array of records. */
+export declare function parseEntryList(format: EntryFormat, text: string): Record<string, unknown>[];
+export declare function serializeEntryList(format: EntryFormat, items: Record<string, unknown>[]): string;
+export declare function stripUndefined<T>(value: T): T;

package/dist/core/entries.js

@@ -0,0 +1,127 @@
+import { Document as YamlDocument, parse as parseYaml, stringify as stringifyYaml, visit as visitYaml, } from "yaml";
+const FRONTMATTER_RE = /^(?:)?---\r?\n([\s\S]*?)\r?\n?---(?:\r?\n|$)/;
+/** Split a Markdown/MDX file into YAML frontmatter and body. */
+export function splitFrontmatter(text) {
+    const m = text.match(FRONTMATTER_RE);
+    if (!m)
+        return { data: {}, body: text, hasFrontmatter: false };
+    const yaml = m[1];
+    const body = text.slice(m[0].length);
+    let data = {};
+    if (yaml.trim()) {
+        data = parseYaml(yaml, { strict: false });
+    }
+    if (data === null || typeof data !== "object" || Array.isArray(data))
+        data = {};
+    return { data: data, body, hasFrontmatter: true };
+}
+export function parseEntry(format, text) {
+    switch (format) {
+        case "md":
+        case "mdx": {
+            const { data, body } = splitFrontmatter(text);
+            return { data, body: body.replace(/^\r?\n/, "") };
+        }
+        case "yaml": {
+            const data = parseYaml(text) ?? {};
+            return { data: asRecord(data), body: "" };
+        }
+        case "json": {
+            const data = text.trim() ? JSON.parse(text) : {};
+            return { data: asRecord(data), body: "" };
+        }
+    }
+}
+function asRecord(v) {
+    return v && typeof v === "object" && !Array.isArray(v)
+        ? v
+        : {};
+}
+/**
+ * Strings that YAML 1.1 parsers (js-yaml, which Astro uses for frontmatter)
+ * would turn into something other than a string: timestamps become Dates,
+ * `y`/`n`/`yes`/`no`/`on`/`off` become booleans, leading-zero digits become
+ * octal numbers. These are written double-quoted so they survive a round trip.
+ */
+const YAML11_UNSAFE = [
+    /^\d{4}-\d{1,2}-\d{1,2}([Tt ]|$)/,
+    /^(y|n|yes|no|on|off|true|false|null|~)$/i,
+    /^0\d+$/,
+    /^[+-]?\d+(:\d+)+(\.\d+)?$/,
+    /^[+-]?\.(inf|nan)$/i,
+];
+export function needsYamlQuotes(value) {
+    return YAML11_UNSAFE.some((re) => re.test(value));
+}
+export function stringifyFrontmatter(data) {
+    const clean = stripUndefined(data);
+    if (Object.keys(clean).length === 0)
+        return "";
+    const doc = new YamlDocument(clean);
+    visitYaml(doc, {
+        Scalar(_key, node) {
+            if (typeof node.value === "string" && needsYamlQuotes(node.value))
+                node.type = "QUOTE_DOUBLE";
+        },
+    });
+    return doc
+        .toString({
+        lineWidth: 0,
+        defaultStringType: "PLAIN",
+        defaultKeyType: "PLAIN",
+    })
+        .replace(/\n$/, "");
+}
+export function serializeEntry(format, entry) {
+    switch (format) {
+        case "md":
+        case "mdx": {
+            const fm = stringifyFrontmatter(entry.data);
+            const body = entry.body.replace(/\s+$/, "");
+            if (!fm)
+                return body ? `${body}\n` : "";
+            return body ? `---\n${fm}\n---\n\n${body}\n` : `---\n${fm}\n---\n`;
+        }
+        case "yaml":
+            return stringifyYaml(stripUndefined(entry.data), { lineWidth: 0 });
+        case "json":
+            return `${JSON.stringify(stripUndefined(entry.data), null, 2)}\n`;
+    }
+}
+/** Single-file collections hold an array of records. */
+export function parseEntryList(format, text) {
+    const value = format === "json"
+        ? text.trim()
+            ? JSON.parse(text)
+            : []
+        : (parseYaml(text) ?? []);
+    if (Array.isArray(value))
+        return value.filter((v) => v && typeof v === "object");
+    if (value && typeof value === "object") {
+        // Allow `{ id: {...}, id2: {...} }` keyed objects too.
+        return Object.entries(value).map(([id, v]) => ({
+            id,
+            ...v,
+        }));
+    }
+    return [];
+}
+export function serializeEntryList(format, items) {
+    const clean = items.map(stripUndefined);
+    return format === "json"
+        ? `${JSON.stringify(clean, null, 2)}\n`
+        : stringifyYaml(clean, { lineWidth: 0 });
+}
+export function stripUndefined(value) {
+    if (Array.isArray(value))
+        return value.map(stripUndefined);
+    if (value && typeof value === "object" && !(value instanceof Date)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (v !== undefined)
+                out[k] = stripUndefined(v);
+        }
+        return out;
+    }
+    return value;
+}

package/dist/core/index-types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The build-time index. The integration scans every collection at build time
+ * and records each entry file's git blob SHA alongside its parsed frontmatter.
+ * At runtime the GitHub source compares the live tree against this index and
+ * only fetches files that changed since the deploy, so listings are fast even
+ * on a cold worker.
+ */
+export interface IndexedFile {
+    sha: string;
+    data: Record<string, unknown>;
+    /** First ~200 characters of the body, for list previews. */
+    excerpt?: string;
+    /** Whether the body had any content. */
+    hasBody?: boolean;
+}
+export interface BuildIndex {
+    builtAt: string;
+    files: Record<string, IndexedFile>;
+}
+export declare const EMPTY_INDEX: BuildIndex;

package/dist/core/index-types.js

@@ -0,0 +1 @@
+export const EMPTY_INDEX = { builtAt: "", files: {} };

package/dist/core/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./source.js";
+export * from "./cache.js";
+export * from "./entries.js";
+export * from "./paths.js";
+export * from "./service.js";
+export * from "./api.js";
+export * from "./auth.js";
+export * from "./roles.js";
+export * from "./mail.js";
+export * from "./index-types.js";
+export * from "./values.js";
+export { GitHubSource } from "./sources/github.js";
+export * from "./sources/github-app.js";

package/dist/core/index.js

@@ -0,0 +1,13 @@
+export * from "./source.js";
+export * from "./cache.js";
+export * from "./entries.js";
+export * from "./paths.js";
+export * from "./service.js";
+export * from "./api.js";
+export * from "./auth.js";
+export * from "./roles.js";
+export * from "./mail.js";
+export * from "./index-types.js";
+export * from "./values.js";
+export { GitHubSource } from "./sources/github.js";
+export * from "./sources/github-app.js";

package/dist/core/mail.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Outbound email, used for login codes and invitations. Vestry ships a
+ * Resend adapter and a console mailer for development; anything with an HTTP
+ * API is a few lines behind the same interface.
+ */
+export interface MailMessage {
+    to: string;
+    subject: string;
+    text: string;
+    html?: string;
+}
+export interface Mailer {
+    send(message: MailMessage): Promise<void>;
+}
+export declare class MailError extends Error {
+    constructor(message: string);
+}
+export declare function resendMailer(opts: {
+    apiKey: string;
+    from: string;
+    apiBase?: string;
+}): Mailer;
+/** Prints messages instead of sending them (development). */
+export declare function consoleMailer(log?: (line: string) => void): Mailer;
+/** Collects messages for tests. */
+export declare function memoryMailer(): Mailer & {
+    sent: MailMessage[];
+};

package/dist/core/mail.js

@@ -0,0 +1,62 @@
+export class MailError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MailError";
+    }
+}
+export function resendMailer(opts) {
+    const base = (opts.apiBase ?? "https://api.resend.com").replace(/\/$/, "");
+    return {
+        async send(message) {
+            const res = await fetch(`${base}/emails`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${opts.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    from: opts.from,
+                    to: [message.to],
+                    subject: message.subject,
+                    text: message.text,
+                    ...(message.html ? { html: message.html } : {}),
+                }),
+            });
+            if (!res.ok) {
+                let detail = `${res.status}`;
+                try {
+                    const body = (await res.json());
+                    if (body.message)
+                        detail = `${body.message} (${res.status})`;
+                }
+                catch {
+                    /* ignore */
+                }
+                throw new MailError(`Resend rejected the email: ${detail}`);
+            }
+        },
+    };
+}
+/** Prints messages instead of sending them (development). */
+export function consoleMailer(log = (line) => console.log(line)) {
+    return {
+        async send(message) {
+            log([
+                "",
+                `[vestry] Email to ${message.to}: ${message.subject}`,
+                ...message.text.split("\n").map((l) => `    ${l}`),
+                "",
+            ].join("\n"));
+        },
+    };
+}
+/** Collects messages for tests. */
+export function memoryMailer() {
+    const sent = [];
+    return {
+        sent,
+        async send(message) {
+            sent.push(message);
+        },
+    };
+}

package/dist/core/paths.d.ts

@@ -0,0 +1,35 @@
+import type { CollectionConfig, EntryFormat, SingletonConfig } from "../config/types.js";
+export declare function normalizePath(p: string): string;
+export declare function extname(p: string): string;
+export declare function basename(p: string): string;
+export declare function dirname(p: string): string;
+export declare function joinPath(...parts: string[]): string;
+/** Resolve `../x` style segments against a directory (repo-relative). */
+export declare function resolveRelative(fromDir: string, rel: string): string;
+/** Relative path from one directory to a file (repo-relative, posix). */
+export declare function relativePath(fromDir: string, toFile: string): string;
+export declare function formatFromPath(p: string): EntryFormat;
+export interface PathPattern {
+    /** Literal path prefix before the wildcard, e.g. `src/content/sermons/`. */
+    prefix: string;
+    /** Literal suffix after the wildcard, e.g. `.mdx`. */
+    suffix: string;
+    /** Whether the wildcard was `**` (slugs may contain `/`). */
+    deep: boolean;
+    /** No wildcard: a single file containing all entries. */
+    single: boolean;
+    /** Directory that holds the entries (prefix without trailing slash). */
+    directory: string;
+}
+export declare function parsePathPattern(pattern: string): PathPattern;
+export declare function entryPath(pattern: PathPattern, slug: string): string;
+/** Returns the slug for a file path if it matches the pattern, else null. */
+export declare function slugFromPath(pattern: PathPattern, path: string): string | null;
+export declare function collectionFormat(c: CollectionConfig | SingletonConfig): EntryFormat;
+export declare function slugify(input: string): string;
+/** Fill `{field}` placeholders from a record. Values are slugified when `slug` is true. */
+export declare function fillTemplate(template: string, values: Record<string, unknown>, opts?: {
+    slug?: boolean;
+}): string;
+export declare function isSafeSlug(slug: string): boolean;
+export declare function isSafeRepoPath(path: string): boolean;