uncial-cms 0.0.0

package/dist/index-page.js

@@ -0,0 +1,224 @@
+/**
+ * `/uncial/` site-index runtime (PRD §6.6, D2): list/create/delete pages and
+ * the hash-routed fallback editor (`#/<path>/`). Framework-agnostic plain DOM,
+ * same style as mountEditorPage — the SvelteKit index route is just a shell
+ * that calls this.
+ */
+import { createPage, deletePage, listPages } from './index-actions.js';
+import { mountEditorPage } from './mount.js';
+import { defaultMapPathToSource, hashForPagePath, pagePathFromHash, validatePagePath } from './paths/index.js';
+import { createGitHubAdapter, popupSessionProvider } from './github/index.js';
+import { createLocalAdapter } from './local/adapter.js';
+import { localSessionProvider } from './local/session.js';
+import { UNCIAL_CMS_RUNTIME_SENTINEL } from './sentinel.js';
+function createAdapter(config) {
+    if (config.forge === 'github')
+        return createGitHubAdapter();
+    if (config.forge === 'local')
+        return createLocalAdapter();
+    throw new Error(`Unknown forge "${config.forge}".`);
+}
+export function mountIndexPage(target, opts) {
+    const { config, basePath = '' } = opts;
+    const sessionProvider = opts.sessionProvider ?? (config.forge === 'local' ? localSessionProvider : popupSessionProvider);
+    const locationLabel = config.forge === 'github' ? `${config.repo}@${config.branch}` : 'the local checkout';
+    const branchLabel = config.forge === 'github' ? config.branch : 'the local checkout';
+    const mapPathToSource = opts.mapPathToSource ?? ((path) => defaultMapPathToSource(path, config.contentDir));
+    const root = document.createElement('div');
+    root.className = 'uncial-cms-index';
+    root.dataset.uncialCmsRuntime = UNCIAL_CMS_RUNTIME_SENTINEL;
+    const status = document.createElement('p');
+    status.className = 'uncial-cms-status';
+    status.setAttribute('role', 'status');
+    const listView = document.createElement('section');
+    listView.className = 'uncial-cms-index-list';
+    const editorView = document.createElement('section');
+    editorView.className = 'uncial-cms-fallback-editor';
+    editorView.hidden = true;
+    root.append(status, listView, editorView);
+    target.append(root);
+    let destroyed = false;
+    let adapter = null;
+    let session = null;
+    let editorHandle = null;
+    let currentHash = location.hash;
+    let revertingHash = false;
+    const setStatus = (text) => {
+        status.textContent = text;
+    };
+    const livePageUrl = (pagePath) => `${basePath}/${pagePath === '' ? '' : `${pagePath}/`}`;
+    const renderList = (pages) => {
+        listView.replaceChildren();
+        const heading = document.createElement('h2');
+        heading.textContent = 'Pages';
+        const list = document.createElement('ul');
+        for (const page of pages) {
+            const item = document.createElement('li');
+            const live = document.createElement('a');
+            live.href = livePageUrl(page.pagePath);
+            live.textContent = page.pagePath === '' ? '(site root)' : `/${page.pagePath}/`;
+            // Always link the fallback editor — it works whether or not the page's
+            // static variant has deployed yet.
+            const edit = document.createElement('a');
+            edit.href = hashForPagePath(page.pagePath);
+            edit.textContent = 'Edit';
+            const del = document.createElement('button');
+            del.type = 'button';
+            del.textContent = 'Delete';
+            del.addEventListener('click', () => void onDelete(page));
+            item.append(live, ' ', edit, ' ', del);
+            list.append(item);
+        }
+        const form = document.createElement('form');
+        form.className = 'uncial-cms-create';
+        const label = document.createElement('label');
+        label.textContent = 'New page path ';
+        const input = document.createElement('input');
+        input.name = 'path';
+        input.placeholder = 'team/new-page';
+        label.append(input);
+        const submit = document.createElement('button');
+        submit.type = 'submit';
+        submit.textContent = 'Create page';
+        const message = document.createElement('p');
+        message.className = 'uncial-cms-create-message';
+        message.setAttribute('role', 'alert');
+        message.hidden = true;
+        form.append(label, ' ', submit, message);
+        form.addEventListener('submit', (event) => {
+            event.preventDefault();
+            void onCreate(input.value, message, submit);
+        });
+        listView.append(heading, list, form);
+    };
+    const refreshList = async () => {
+        if (!adapter)
+            return;
+        setStatus('Loading pages…');
+        const pages = await listPages(adapter, config.contentDir, opts.mapSourceToPath);
+        if (destroyed)
+            return;
+        renderList(pages);
+        setStatus(`Editing ${locationLabel} as ${session.user.login}`);
+    };
+    const onCreate = async (raw, message, submit) => {
+        const result = validatePagePath(raw);
+        if (!result.ok) {
+            message.hidden = false;
+            message.textContent = result.message;
+            return;
+        }
+        if (!adapter || !session)
+            return;
+        message.hidden = true;
+        submit.disabled = true;
+        try {
+            await createPage({ adapter, blocks: opts.blocks, schema: opts.schema, author: session.user }, { pagePath: result.path, sourcePath: mapPathToSource(result.path) });
+            // Open the fallback editor immediately — the static variant only
+            // appears after the next deploy.
+            location.hash = hashForPagePath(result.path);
+        }
+        catch (error) {
+            message.hidden = false;
+            message.textContent = error instanceof Error ? error.message : 'Create failed.';
+        }
+        finally {
+            submit.disabled = false;
+        }
+    };
+    const onDelete = async (page) => {
+        if (!adapter)
+            return;
+        const confirmed = window.confirm(`Delete ${page.sourcePath} from ${branchLabel}? This commits the deletion immediately.`);
+        if (!confirmed)
+            return;
+        try {
+            await deletePage(adapter, page);
+            await refreshList();
+        }
+        catch (error) {
+            setStatus(error instanceof Error ? error.message : 'Delete failed.');
+        }
+    };
+    const closeEditor = () => {
+        editorHandle?.destroy();
+        editorHandle = null;
+        editorView.replaceChildren();
+        editorView.hidden = true;
+        listView.hidden = false;
+    };
+    const openEditor = (pagePath) => {
+        closeEditor();
+        listView.hidden = true;
+        editorView.hidden = false;
+        const back = document.createElement('a');
+        back.href = '#';
+        back.textContent = '← Back to index';
+        const heading = document.createElement('h2');
+        heading.textContent = pagePath === '' ? 'Editing site root' : `Editing /${pagePath}/`;
+        const mountTarget = document.createElement('div');
+        editorView.append(back, heading, mountTarget);
+        editorHandle = mountEditorPage(mountTarget, {
+            config,
+            sourcePath: mapPathToSource(pagePath),
+            pagePath,
+            blocks: opts.blocks,
+            schema: opts.schema,
+            sessionProvider,
+            editorStylesheets: opts.editorStylesheets
+        });
+    };
+    const applyHash = () => {
+        const pagePath = pagePathFromHash(location.hash);
+        if (pagePath === null) {
+            closeEditor();
+            void refreshList().catch((error) => {
+                setStatus(error instanceof Error ? error.message : 'Failed to list pages.');
+            });
+        }
+        else {
+            openEditor(pagePath);
+        }
+        currentHash = location.hash;
+    };
+    const onHashChange = () => {
+        if (revertingHash) {
+            revertingHash = false;
+            return;
+        }
+        if (editorHandle?.isDirty() && !window.confirm('Discard unsaved changes?')) {
+            revertingHash = true;
+            location.hash = currentHash;
+            return;
+        }
+        applyHash();
+    };
+    const onBeforeUnload = (event) => {
+        if (editorHandle?.isDirty())
+            event.preventDefault();
+    };
+    window.addEventListener('hashchange', onHashChange);
+    window.addEventListener('beforeunload', onBeforeUnload);
+    const load = async () => {
+        setStatus('Signing in…');
+        adapter = createAdapter(config);
+        session = await adapter.authenticate(config, sessionProvider);
+        if (destroyed)
+            return;
+        applyHash();
+    };
+    void load().catch((error) => {
+        if (destroyed)
+            return;
+        setStatus(error instanceof Error ? error.message : 'Failed to load the site index.');
+    });
+    return {
+        destroy() {
+            destroyed = true;
+            window.removeEventListener('hashchange', onHashChange);
+            window.removeEventListener('beforeunload', onBeforeUnload);
+            editorHandle?.destroy();
+            root.remove();
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export type { ForgeAdapter, ForgeSession, GitHubSiteConfig, SessionProvider, UncialCmsSiteConfig } from './types.js';
+export { defineSite, DEFAULT_APP_SLUG, DEFAULT_AUTH_WORKER_URL, type Site, type SiteOptions } from './define-site.js';
+export { ConflictError, NotFoundError } from './errors.js';
+export { UNCIAL_CMS_RUNTIME_SENTINEL } from './sentinel.js';
+export { mountEditorPage, type MountEditorPageOptions } from './mount.js';
+export { createEditorSession, defaultSessionProvider, forgeAdapter, type CreateEditorSessionOptions } from './editor-session.js';
+export { createEditorController, conflictDownloadFilename, type DownloadPayload, type EditorController, type EditorControllerOptions, type EditorPageUi, type StatusView } from './editor-controller.js';
+export { mountIndexPage, type MountIndexPageOptions } from './index-page.js';
+export { createPage, deletePage, listPages, uploadAsset, uploadImageAsset, type PageRef, type UploadAssetFile, type UploadAssetOptions, type UploadAssetResult, type UploadImageAssetOptions } from './index-actions.js';
+export { fitImage, type FitOptions, type FittedImage, type ImageEncoder, type EncodableImage } from './fit-image.js';
+export { servedUrl } from './served-url.js';
+export { MAX_CONTENT_BYTES } from './constants.js';
+export { hashForPagePath, pagePathFromHash, validatePagePath } from './paths/index.js';
+export { parseDocument, serializeDocument, type Blocks } from './document.js';
+export { patSessionProvider, popupSessionProvider } from './github/index.js';

package/dist/index.js

@@ -0,0 +1,21 @@
+export { defineSite, DEFAULT_APP_SLUG, DEFAULT_AUTH_WORKER_URL } from './define-site.js';
+export { ConflictError, NotFoundError } from './errors.js';
+export { UNCIAL_CMS_RUNTIME_SENTINEL } from './sentinel.js';
+export { mountEditorPage } from './mount.js';
+/*
+ * The same editing session without a surface, for a host that renders Uncial's
+ * own `Editor` component itself. `mountEditorPage` builds a shadow root and is
+ * the right door for a host with no component model; a framework host wants its
+ * editor in its own tree and its own cascade, and only wants the storage,
+ * autosave, deploy status and conflict recovery from here.
+ */
+export { createEditorSession, defaultSessionProvider, forgeAdapter } from './editor-session.js';
+export { createEditorController, conflictDownloadFilename } from './editor-controller.js';
+export { mountIndexPage } from './index-page.js';
+export { createPage, deletePage, listPages, uploadAsset, uploadImageAsset } from './index-actions.js';
+export { fitImage } from './fit-image.js';
+export { servedUrl } from './served-url.js';
+export { MAX_CONTENT_BYTES } from './constants.js';
+export { hashForPagePath, pagePathFromHash, validatePagePath } from './paths/index.js';
+export { parseDocument, serializeDocument } from './document.js';
+export { patSessionProvider, popupSessionProvider } from './github/index.js';

package/dist/local/adapter.d.ts

@@ -0,0 +1,2 @@
+import type { ForgeAdapter } from '../types.js';
+export declare function createLocalAdapter(): ForgeAdapter;

package/dist/local/adapter.js

@@ -0,0 +1,63 @@
+import { bytesToBase64 } from '../base64.js';
+import { ConflictError, NotFoundError } from '../errors.js';
+import { LOCAL_API_PATH } from './constants.js';
+function encodePath(path) {
+    return path.split('/').map(encodeURIComponent).join('/');
+}
+class LocalAdapter {
+    #config = null;
+    async authenticate(config, provider) {
+        if (config.forge !== 'local') {
+            throw new Error('Local adapter requires a local site configuration.');
+        }
+        this.#config = config;
+        return provider(config);
+    }
+    async readFile(path) {
+        return this.#request('POST', `files/${this.#path(path)}`, {});
+    }
+    async writeFile(path, content, opts) {
+        return this.#request('PUT', `files/${this.#path(path)}`, {
+            content: typeof content === 'string' ? content : bytesToBase64(content),
+            ...(typeof content === 'string' ? {} : { encoding: 'base64' }),
+            // Absent = create or replace outright, as on the GitHub adapter.
+            ...(opts.sha === undefined ? {} : { sha: opts.sha })
+        });
+    }
+    async deleteFile(path, _opts) {
+        await this.#request('DELETE', `files/${this.#path(path)}`, {});
+    }
+    async listDir(path) {
+        // The plugin roots at the repository, so the paths it reports are already
+        // the repo-root-relative ones every forge adapter speaks.
+        const response = await this.#request('POST', `dirs/${this.#path(path)}`, {});
+        return response.entries;
+    }
+    async commitStatus(_commitSha) {
+        return 'success';
+    }
+    /** Repo-root-relative, exactly as the GitHub adapter sends it. */
+    #path(path) {
+        if (!this.#config)
+            throw new Error('Local adapter is not authenticated; call authenticate() first.');
+        return encodePath(path.replace(/^\/+|\/+$/g, ''));
+    }
+    async #request(method, path, body) {
+        const response = await fetch(new URL(`${LOCAL_API_PATH}/${path}`, location.origin), {
+            method,
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        });
+        if (response.ok)
+            return (await response.json());
+        const error = (await response.json().catch(() => ({})));
+        if (response.status === 404)
+            throw new NotFoundError(error.error ?? 'File not found.');
+        if (response.status === 409)
+            throw new ConflictError(error.error);
+        throw new Error(error.error ?? `Local request failed (${response.status}).`);
+    }
+}
+export function createLocalAdapter() {
+    return new LocalAdapter();
+}

package/dist/local/constants.d.ts

@@ -0,0 +1 @@
+export declare const LOCAL_API_PATH = "/__uncial-cms/local";

package/dist/local/constants.js

@@ -0,0 +1 @@
+export const LOCAL_API_PATH = '/__uncial-cms/local';

package/dist/local/index.d.ts

@@ -0,0 +1,4 @@
+export { createLocalAdapter } from './adapter.js';
+export { LOCAL_API_PATH } from './constants.js';
+export { localSessionProvider } from './session.js';
+export { createLocalVitePlugin, type LocalVitePluginOptions } from './vite.js';

package/dist/local/index.js

@@ -0,0 +1,4 @@
+export { createLocalAdapter } from './adapter.js';
+export { LOCAL_API_PATH } from './constants.js';
+export { localSessionProvider } from './session.js';
+export { createLocalVitePlugin } from './vite.js';

package/dist/local/session.d.ts

@@ -0,0 +1,2 @@
+import type { SessionProvider } from '../types.js';
+export declare const localSessionProvider: SessionProvider;

package/dist/local/session.js

@@ -0,0 +1,12 @@
+const localSession = {
+    token: 'local',
+    expiresAt: null,
+    repo: 'local',
+    user: { login: 'local', name: 'Local editor', email: 'local@localhost' }
+};
+export const localSessionProvider = async (config) => {
+    if (config.forge !== 'local') {
+        throw new Error('The local session provider requires a local site configuration.');
+    }
+    return localSession;
+};

package/dist/local/vite.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'vite';
+export interface LocalVitePluginOptions {
+    /** Repository root: every path the endpoint receives resolves against it. */
+    root: string;
+    /** Repo-root-relative directories a request may address, as the site declares them. */
+    permittedRoots: string[];
+}
+export declare function createLocalVitePlugin(options: LocalVitePluginOptions): Plugin;

package/dist/local/vite.js

@@ -0,0 +1,243 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, readdir, rename, rm, unlink, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { MAX_CONTENT_BYTES } from '../constants.js';
+import { LOCAL_API_PATH } from './constants.js';
+/**
+ * A base64 body spends four bytes on every three of payload, and the JSON
+ * envelope adds its keys on top, so the request cap has to clear the envelope of
+ * a `MAX_CONTENT_BYTES` upload — which is exactly the size `fitImage` targets.
+ * The decoded cap in {@link handleWrite} is the one that enforces the limit.
+ */
+const MAX_REQUEST_BYTES = Math.ceil(MAX_CONTENT_BYTES / 3) * 4 + 1024;
+class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function sendJson(response, status, body) {
+    response.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+    response.end(JSON.stringify(body));
+}
+async function readJson(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += bytes.byteLength;
+        if (size > MAX_REQUEST_BYTES) {
+            throw new HttpError(413, `Request body exceeds ${MAX_REQUEST_BYTES} bytes.`);
+        }
+        chunks.push(bytes);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new HttpError(400, 'Request body must be valid JSON.');
+    }
+}
+function resolveRoots({ root, permittedRoots }) {
+    const repositoryRoot = resolve(root);
+    return {
+        root: repositoryRoot,
+        permitted: permittedRoots.map((declared) => ({
+            declared,
+            absolute: resolve(repositoryRoot, declared)
+        }))
+    };
+}
+function contains(directory, target) {
+    const from = relative(directory, target);
+    return from === '' || (!from.startsWith(`..${sep}`) && from !== '..' && !isAbsolute(from));
+}
+function repositoryPath(roots, encodedPath) {
+    let path;
+    try {
+        path = decodeURIComponent(encodedPath);
+    }
+    catch {
+        throw new HttpError(400, 'Path is not valid URL encoding.');
+    }
+    const target = resolve(roots.root, path);
+    if (!roots.permitted.some((permitted) => contains(permitted.absolute, target))) {
+        const names = roots.permitted.map((permitted) => permitted.declared).join(', ');
+        throw new HttpError(403, `Path must stay within ${names}.`);
+    }
+    return target;
+}
+async function handleRead(request, response, roots, encodedPath) {
+    await readJson(request);
+    const target = repositoryPath(roots, encodedPath);
+    let content;
+    try {
+        content = await readFile(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new HttpError(404, 'File not found.');
+        }
+        throw error;
+    }
+    if (content.byteLength > MAX_CONTENT_BYTES) {
+        throw new HttpError(413, `File exceeds ${MAX_CONTENT_BYTES} bytes.`);
+    }
+    sendJson(response, 200, {
+        content: content.toString('utf8'),
+        sha: createHash('sha256').update(content).digest('hex')
+    });
+}
+async function handleWrite(request, response, roots, encodedPath) {
+    const body = await readJson(request);
+    if (!isRecord(body) || typeof body.content !== 'string') {
+        throw new HttpError(400, 'Write request must contain a string content property.');
+    }
+    if (body.encoding !== undefined && body.encoding !== 'base64') {
+        throw new HttpError(400, 'Write encoding must be base64 when provided.');
+    }
+    if (body.sha !== undefined && typeof body.sha !== 'string') {
+        throw new HttpError(400, 'Write sha must be a string when provided.');
+    }
+    const target = repositoryPath(roots, encodedPath);
+    const content = Buffer.from(body.content, body.encoding === 'base64' ? 'base64' : 'utf8');
+    if (content.byteLength > MAX_CONTENT_BYTES) {
+        throw new HttpError(413, `Content exceeds ${MAX_CONTENT_BYTES} bytes.`);
+    }
+    // A sha means "replace the revision I read"; the GitHub Contents API answers
+    // a stale one with 409, and the editor's conflict recovery is written against
+    // that. Without the check an editor autosaving against the local checkout
+    // would silently overwrite a change made underneath it.
+    if (typeof body.sha === 'string') {
+        let current;
+        try {
+            current = await readFile(target);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            current = null;
+        }
+        const currentSha = current && createHash('sha256').update(current).digest('hex');
+        if (currentSha !== body.sha) {
+            throw new HttpError(409, 'The file changed on disk since it was read.');
+        }
+    }
+    await mkdir(dirname(target), { recursive: true });
+    const temporary = `${target}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, content);
+        await rename(temporary, target);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    const sha = createHash('sha256').update(content).digest('hex');
+    sendJson(response, 200, { sha, commitSha: sha });
+}
+async function handleDelete(request, response, roots, encodedPath) {
+    await readJson(request);
+    const target = repositoryPath(roots, encodedPath);
+    try {
+        await unlink(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new HttpError(404, 'File not found.');
+        }
+        throw error;
+    }
+    sendJson(response, 200, {});
+}
+async function handleList(request, response, roots, encodedPath) {
+    await readJson(request);
+    const target = repositoryPath(roots, encodedPath);
+    let entries;
+    try {
+        entries = await readdir(target, { encoding: 'utf8', withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new HttpError(404, 'Directory not found.');
+        }
+        throw error;
+    }
+    sendJson(response, 200, {
+        entries: entries
+            .filter((entry) => entry.isFile() || entry.isDirectory())
+            .map((entry) => ({
+            path: relative(roots.root, resolve(target, entry.name)).split(sep).join('/'),
+            type: entry.isDirectory() ? 'dir' : 'file'
+        }))
+    });
+}
+export function createLocalVitePlugin(options) {
+    const roots = resolveRoots(options);
+    const filePrefix = `${LOCAL_API_PATH}/files/`;
+    const directoryPrefix = `${LOCAL_API_PATH}/dirs/`;
+    return {
+        name: 'uncial-cms:local',
+        apply(_config, env) {
+            return env.command === 'serve';
+        },
+        config(_config, env) {
+            if (env.command !== 'serve')
+                return;
+            const watched = roots.permitted.map((permitted) => permitted.absolute);
+            return {
+                server: {
+                    host: '127.0.0.1',
+                    // Every write under a permitted root arrives through this plugin's
+                    // own endpoint, so a watcher event for one is the author's own
+                    // autosave landing. Watched, it makes Vite full-reload the page
+                    // mid-edit and the editing session goes with it.
+                    watch: {
+                        ignored: [
+                            (path) => watched.some((root) => path === root || path.startsWith(`${root}${sep}`))
+                        ]
+                    }
+                }
+            };
+        },
+        configureServer(server) {
+            server.middlewares.use((request, response, next) => {
+                const path = request.url?.split('?', 1)[0] ?? '';
+                const isFile = path.startsWith(filePrefix);
+                const isDirectory = path.startsWith(directoryPrefix);
+                if (!isFile && !isDirectory)
+                    return next();
+                if (!request.headers['content-type']?.startsWith('application/json')) {
+                    sendJson(response, 415, { error: 'Requests must use application/json.' });
+                    return;
+                }
+                const handler = isDirectory
+                    ? request.method === 'POST'
+                        ? handleList
+                        : null
+                    : request.method === 'POST'
+                        ? handleRead
+                        : request.method === 'PUT'
+                            ? handleWrite
+                            : request.method === 'DELETE'
+                                ? handleDelete
+                                : null;
+                if (!handler) {
+                    sendJson(response, 405, { error: 'Method not allowed.' });
+                    return;
+                }
+                const encodedPath = path.slice((isDirectory ? directoryPrefix : filePrefix).length);
+                void handler(request, response, roots, encodedPath).catch((error) => {
+                    if (error instanceof HttpError) {
+                        sendJson(response, error.status, { error: error.message });
+                        return;
+                    }
+                    next(error);
+                });
+            });
+        }
+    };
+}

package/dist/mount.d.ts

@@ -0,0 +1,43 @@
+import 'uncial/web-components';
+import 'uncial/styles/chrome';
+import type { UncialEditorElement } from 'uncial/web-components';
+import type { SessionProvider, UncialCmsSiteConfig } from './types.js';
+export interface MountEditorPageOptions {
+    config: UncialCmsSiteConfig;
+    sourcePath: string;
+    /** Site-relative page path, used in the deterministic commit message
+     * `uncial-cms: edit <path>`. Falls back to sourcePath. */
+    pagePath?: string;
+    blocks: unknown;
+    schema: unknown;
+    sessionProvider?: SessionProvider;
+    /**
+     * Debounced autosave in milliseconds. When set, the page saves on its own
+     * this long after the last change and renders no Save button — the mode a
+     * local-filesystem backend wants, where the file is the document and there
+     * is nothing to reconcile. Omitted keeps the Save button and manual saving.
+     */
+    autosaveMs?: number;
+    /**
+     * How the editor renders its block attributes panel — see uncial's
+     * `attributesPanel`. A site whose Editor variant is meant to look like the
+     * published page wants `'overlay'`, so the panel costs the document no width.
+     */
+    attributesPanel?: UncialEditorElement['attributesPanel'];
+    /**
+     * `'bare'` drops the editor's own surface and inline padding so the document
+     * is laid out in exactly the box the host gives it — see uncial's
+     * `presentation`. Pairs with `attributesPanel: 'overlay'` for WYSIWYG parity.
+     */
+    presentation?: UncialEditorElement['presentation'];
+    /**
+     * Stylesheet URLs to load inside the editor's shadow root. Defaults to
+     * mirroring every stylesheet of the host page (WYSIWYG parity: the editor
+     * renders behind a shadow boundary, which page styles do not cross).
+     */
+    editorStylesheets?: string[];
+}
+export declare function mountEditorPage(target: HTMLElement, opts: MountEditorPageOptions): {
+    destroy(): void;
+    isDirty(): boolean;
+};