@lettercamp/cli 0.1.7 → 0.1.9

package/dist/account.js

@@ -12,7 +12,7 @@ export function apiOrigin() {
     }
     return url.origin;
 }
-async function readConfig(name) {
+export async function readConfig(name) {
     try {
         return JSON.parse(await readFile(path.join(configRoot(), name), 'utf8'));
     }
@@ -22,7 +22,7 @@ async function readConfig(name) {
         throw new Error(`Unable to read Lettercamp ${name}. Check ${configRoot()}.`);
     }
 }
-async function saveConfig(name, value) {
+export async function saveConfig(name, value) {
     await mkdir(configRoot(), { recursive: true, mode: 0o700 });
     if (process.platform !== 'win32')
         await chmod(configRoot(), 0o700);
@@ -42,12 +42,12 @@ export async function credentials() {
     }
     return saved;
 }
-export async function apiRequest(route, options = {}, token) {
+export async function apiRequest(route, options = {}, token, timeout = 30_000) {
     const headers = new Headers(options.headers);
     if (token)
         headers.set('Authorization', `Bearer ${token}`);
     try {
-        return await fetch(new URL(route, apiOrigin()), { ...options, headers, redirect: 'error', signal: AbortSignal.timeout(30_000) });
+        return await fetch(new URL(route, apiOrigin()), { ...options, headers, redirect: 'error', signal: AbortSignal.timeout(timeout) });
     }
     catch {
         throw new Error('Unable to reach Lettercamp. Check your connection and try again.');
@@ -81,7 +81,7 @@ async function openBrowser(url) {
 export async function login(options) {
     const previous = await readConfig('credentials.json');
     const name = options.name || `Lettercamp CLI on ${hostname()}`.slice(0, 80);
-    const login = await responseJson(await apiRequest('/api/cli/login', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name }) }));
+    const login = await responseJson(await apiRequest('/api/cli/login', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name, publishing: true }) }));
     const verification = new URL(login.verification_uri_complete);
     if (verification.origin !== apiOrigin() || verification.pathname !== '/cli/login')
         throw new Error('Lettercamp returned an unexpected login address.');
@@ -149,7 +149,7 @@ export async function logout() {
     await rm(path.join(configRoot(), 'credentials.json'), { force: true });
     console.log('Signed out.');
 }
-async function projectPath() {
+export async function projectPath() {
     const cwd = await realpath(process.cwd());
     for (let directory = cwd;; directory = path.dirname(directory)) {
         try {
@@ -170,8 +170,20 @@ export async function selectUploadSite(token, requested) {
     const site = selected ? sites.find(item => item.id === selected || item.slug === selected) : sites.length === 1 ? sites[0] : undefined;
     if (!site) {
         if (!sites.length)
-            throw new Error('No accessible sites. Create a site in Lettercamp first.');
+            throw new Error('No accessible sites. Run lettercamp deploy to create one.');
         throw new Error(`${selected ? 'That site is unavailable to this account.' : 'Choose a site for this publication.'} Use --site <slug>. Available sites: ${sites.map(item => item.slug).join(', ')}`);
     }
-    return { site, remember: () => saveConfig('sites.json', { ...bindings, [project]: { origin: apiOrigin(), siteId: site.id } }) };
+    return { site, remember: () => saveBinding({ ...(binding?.origin === apiOrigin() && binding.siteId === site.id ? binding : {}), origin: apiOrigin(), siteId: site.id }) };
+}
+export async function getBinding() {
+    const bindings = await readConfig('sites.json') ?? {};
+    const binding = bindings[await projectPath()];
+    return binding?.origin === apiOrigin() ? binding : null;
+}
+export async function saveBinding(binding) {
+    const bindings = await readConfig('sites.json') ?? {};
+    await saveConfig('sites.json', { ...bindings, [await projectPath()]: binding });
+}
+export async function removeConfig(name) {
+    await rm(path.join(configRoot(), name), { force: true });
 }

package/dist/build.js

@@ -1,37 +1,54 @@
+import { publicationLinks } from './publication-links.js';
+import { codeBlocks } from "./code-highlight.js";
+import { componentBlocks } from "./component-blocks.js";
 import path from 'node:path';
 import { build } from 'astro';
 import mdx from '@astrojs/mdx';
 import { unified } from '@astrojs/markdown-remark';
 import { prepareWorkspace } from './workspace.js';
 import { readingTime } from './reading-time.js';
+import { mediaDimensions } from './media-dimensions.js';
+import { reactViteConfig } from './react.js';
 export async function buildSite(directory, options) {
     const origin = new URL(options.site);
     if (!['https:', 'http:'].includes(origin.protocol))
         throw new Error('Use an HTTP or HTTPS site URL.');
+    if (origin.username || origin.password || origin.search || origin.hash)
+        throw new Error('Use a site URL without credentials, query parameters, or a fragment.');
     const root = path.resolve(directory);
     const outDir = path.resolve(root, options.outDir ?? 'dist');
     const overlaps = (a, b) => a === b || a.startsWith(b + path.sep) || b.startsWith(a + path.sep);
-    if (outDir === root || root.startsWith(outDir + path.sep) || ['pages', 'public'].some(name => overlaps(outDir, path.join(root, name)))) {
+    if (outDir === root || root.startsWith(outDir + path.sep) || ['pages', 'public', 'components'].some(name => overlaps(outDir, path.join(root, name)))) {
         throw new Error('Output must not replace the publication or its source files.');
     }
     const { workspace, cleanup } = await prepareWorkspace(root);
     const previousCwd = process.cwd();
+    const previousNodeEnv = process.env.NODE_ENV;
     try {
+        // The React integration imports react-dom to detect its version. Select the
+        // production runtime before loading it, as Astro's CLI does before a build.
+        process.env.NODE_ENV = 'production';
+        const { default: react } = await import('@astrojs/react');
         // Astro 7 places temporary prerender modules relative to cwd when outDir
         // is external. Keep them beside the renderer's node_modules, not the content.
         process.chdir(workspace);
         await build({
-            root: workspace, configFile: false, site: origin.origin,
+            root: workspace, configFile: false, site: origin.origin, base: origin.pathname, trailingSlash: 'always',
             cacheDir: path.join(workspace, '.cache'),
-            publicDir: path.join(workspace, 'public'), outDir, output: 'static',
-            integrations: [mdx()],
-            markdown: { processor: unified({ remarkPlugins: [readingTime] }) },
+            publicDir: path.join(workspace, '.lettercamp-no-public'), outDir, output: 'static',
+            integrations: [mdx(), react()],
+            vite: reactViteConfig,
+            markdown: { syntaxHighlight: false, processor: unified({ remarkPlugins: [readingTime, codeBlocks, componentBlocks, [mediaDimensions, { root }], [publicationLinks, { basePath: origin.pathname }]], rehypePlugins: [[mediaDimensions, { root }]] }) },
             build: { format: 'directory', ...(options.assetsPrefix ? { assetsPrefix: options.assetsPrefix } : {}) },
         });
         return outDir;
     }
     finally {
         process.chdir(previousCwd);
+        if (previousNodeEnv === undefined)
+            delete process.env.NODE_ENV;
+        else
+            process.env.NODE_ENV = previousNodeEnv;
         await cleanup();
     }
 }

package/dist/cli.js

@@ -4,10 +4,10 @@ import { preview } from './preview.js';
 export async function run(argv = process.argv) {
     const program = new Command()
         .name('lettercamp')
-        .description('Create and preview your Lettercamp publication.')
+        .description('Create, preview, and publish your Lettercamp publication.')
         .version(version, '-v, --version', 'Show the installed CLI version');
     program.command('login')
-        .description('Sign in through your browser to upload images')
+        .description('Sign in through your browser to publish and manage your site')
         .option('--no-browser', 'Print the approval link without opening a browser')
         .option('--name <name>', 'Name for this CLI session')
         .action(async (options) => { const { login } = await import('./account.js'); await login(options); });
@@ -19,11 +19,12 @@ export async function run(argv = process.argv) {
         .description('Revoke this CLI session and remove its local credential')
         .action(async () => { const { logout } = await import('./account.js'); await logout(); });
     program.command('upload')
-        .description('Upload an image and print its permanent URL')
-        .argument('<file>', 'JPEG, PNG, WebP, or GIF image, up to 10 MB')
+        .description('Upload images or fonts and print their permanent URLs')
+        .argument('<files...>', 'JPEG, PNG, WebP, GIF, TTF, OTF, WOFF, or WOFF2 files, up to 10 MB each')
         .option('--site <slug>', 'Destination site (remembered for this local publication)')
-        .option('--json', 'Print the URL and dimensions as JSON')
-        .action(async (file, options) => { const { upload } = await import('./upload.js'); await upload(file, options); });
+        .option('--json', 'Print URL and image dimensions or font settings; multiple files return an array')
+        .addHelpText('after', '\nExamples:\n  lettercamp upload cover.png portrait.jpg --site my-blog\n  lettercamp upload brand.woff2 --json\n\nMultiple files print filename<TAB>URL. Failed files are reported and remaining uploads continue.\nThe command exits unsuccessfully if any upload fails. Single-file output is unchanged.')
+        .action(async (files, options) => { const { upload } = await import('./upload.js'); await upload(files, options); });
     program.command('new')
         .description('Download the starter into a new or empty directory')
         .argument('[directory]', 'Destination directory', 'my-lettercamp')
@@ -31,6 +32,14 @@ export async function run(argv = process.argv) {
         const { createSite } = await import('./new.js');
         await createSite(directory);
     });
+    program.command('deploy')
+        .description('Publish this folder; create or connect a site on first use')
+        .action(async () => { const { deploy } = await import('./deploy.js'); await deploy(); });
+    program.command('domain')
+        .description('Connect an address, resume setup, or remove the current connection')
+        .argument('[address]', 'A hostname, a URL with a subfolder, or remove')
+        .addHelpText('after', '\nExamples:\n  lettercamp domain blog.example.com\n  lettercamp domain example.com/blog\n  lettercamp domain\n  lettercamp domain remove')
+        .action(async (address) => { const { domain } = await import('./domain.js'); await domain(address); });
     program.command('version')
         .description('Show the installed and latest published CLI versions')
         .action(showVersion);

package/dist/code-block.js

@@ -0,0 +1,50 @@
+// Generated from lettercamp/lib/code-block.ts.
+export const codeThemes = { classic: "Classic", ocean: "Ocean", forest: "Forest", mono: "Monochrome" };
+const settingPattern = /(?:^|\s)lc-(width|wrap|theme|caption)=([^\s]*)/g;
+export function readCodeSettings(meta = "") {
+    const settings = { width: "regular", wrap: true, theme: "classic", caption: "" };
+    for (const match of meta.matchAll(settingPattern)) {
+        const [, key, value] = match;
+        if (key === "width" && (value === "regular" || value === "wide" || value === "full"))
+            settings.width = value;
+        if (key === "theme" && Object.hasOwn(codeThemes, value))
+            settings.theme = value;
+        if (key === "wrap")
+            settings.wrap = value !== "false";
+        if (key === "caption") {
+            try {
+                settings.caption = decodeURIComponent(value);
+            }
+            catch { /* Keep malformed source editable. */ }
+        }
+    }
+    return settings;
+}
+export function writeCodeSettings(meta, patch) {
+    const settings = { ...readCodeSettings(meta), ...patch };
+    return [meta.replace(settingPattern, "").trim(), `lc-width=${settings.width}`, `lc-wrap=${settings.wrap}`, `lc-theme=${settings.theme}`,
+        ...(settings.caption ? [`lc-caption=${encodeURIComponent(settings.caption)}`] : [])].filter(Boolean).join(" ");
+}
+// The editor and both publication renderers use the same token classes and palette.
+export const codeBlockStyles = `
+[data-lettercamp-code] { --code-keyword: #8250a0; --code-string: #3d7757; --code-number: #a15c32; --code-name: #326b99; --code-comment: #93939b; color: #414146; }
+[data-lettercamp-code][data-code-width] { margin-block: 24px; }
+[data-lettercamp-code][data-code-theme="ocean"] { --code-keyword: #3d62a8; --code-string: #277c85; --code-number: #98623e; --code-name: #6961a4; }
+[data-lettercamp-code][data-code-theme="forest"] { --code-keyword: #47724a; --code-string: #827030; --code-number: #a25d47; --code-name: #3c7b79; }
+[data-lettercamp-code][data-code-theme="mono"] { --code-keyword: #45454a; --code-string: #62626a; --code-number: #62626a; --code-name: #45454a; }
+[data-lettercamp-code] .tok-keyword, [data-lettercamp-code] .tok-operator { color: var(--code-keyword); }
+[data-lettercamp-code] .tok-string, [data-lettercamp-code] .tok-string2, [data-lettercamp-code] .tok-inserted { color: var(--code-string); }
+[data-lettercamp-code] .tok-number, [data-lettercamp-code] .tok-bool, [data-lettercamp-code] .tok-atom, [data-lettercamp-code] .tok-literal { color: var(--code-number); }
+[data-lettercamp-code] .tok-typeName, [data-lettercamp-code] .tok-className, [data-lettercamp-code] .tok-propertyName, [data-lettercamp-code] .tok-definition, [data-lettercamp-code] .tok-variableName2, [data-lettercamp-code] .tok-labelName { color: var(--code-name); }
+[data-lettercamp-code] .tok-comment, [data-lettercamp-code] .tok-meta { color: var(--code-comment); }
+[data-lettercamp-code] .tok-invalid, [data-lettercamp-code] .tok-deleted { color: #aa4747; }
+[data-lettercamp-code] .tok-strong { font-weight: 600; }
+[data-lettercamp-code] .tok-emphasis { font-style: italic; }
+figure[data-lettercamp-code] > pre { box-sizing: border-box; margin: 0; padding: 16px 0; overflow-x: auto; border-radius: 8px; background: #fafafa; color: #414146; font: 13px/1.7 ui-monospace, SFMono-Regular, Menlo, monospace; tab-size: 4; }
+figure[data-lettercamp-code] > pre > code { display: block; width: max-content; min-width: 100%; padding: 0; background: transparent; color: inherit; font: inherit; white-space: normal; counter-reset: code-line; }
+[data-lettercamp-code] .code-line { position: relative; display: block; box-sizing: border-box; min-height: 1.7em; padding: 0 18px 0 calc(var(--code-gutter, 3ch) + 24px); white-space: pre; }
+[data-lettercamp-code] .code-line::before { position: absolute; left: 8px; width: var(--code-gutter, 3ch); text-align: right; content: counter(code-line); counter-increment: code-line; color: #b4b4bc; user-select: none; font-variant-numeric: tabular-nums; }
+[data-lettercamp-code][data-code-wrap="true"] > pre > code { width: 100%; }
+[data-lettercamp-code][data-code-wrap="true"] .code-line { white-space: pre-wrap; overflow-wrap: anywhere; }
+figure[data-lettercamp-code] > figcaption { margin: 8px 0 0; color: #888; font: 13px/1.5 var(--font-family, inherit); text-align: center; overflow-wrap: anywhere; }
+`;

package/dist/code-detection.js

@@ -0,0 +1,24 @@
+// Generated from lettercamp/lib/code-detection.ts.
+// Keep detection identical in the editor, draft preview, and publication build.
+// Explicit languages (including plain text) always take precedence.
+export const isAutomaticCodeLanguage = (language) => !language.trim() || language.toLowerCase() === "auto";
+const candidates = ["javascript", "typescript", "python", "json", "xml", "css", "bash", "sql", "yaml", "markdown", "java", "c", "cpp", "csharp", "go", "rust", "ruby", "php", "swift", "kotlin"];
+export async function resolveCodeLanguage(code, language = "") {
+    if (!isAutomaticCodeLanguage(language))
+        return language;
+    const sample = code.slice(0, 20000).trim();
+    // Prose can score against language keywords; require some code structure too.
+    if (!sample || !/[{}()[\];=<>`#$:|\\]/.test(sample))
+        return "txt";
+    try {
+        const { default: detector } = await import("highlight.js/lib/common");
+        const result = detector.highlightAuto(sample, candidates.filter(name => name !== "css" || /[{}]|^\s*@[\w-]+/m.test(sample)));
+        // Short or ambiguous snippets can remain plain until there is enough evidence.
+        if (!result.language || result.relevance < 2)
+            return "txt";
+        return result.language === "xml" ? "html" : result.language;
+    }
+    catch {
+        return "txt";
+    }
+}

package/dist/code-highlight.js

@@ -0,0 +1,54 @@
+// Generated from lettercamp/lib/code-highlight.ts.
+import { resolveCodeLanguage } from "./code-detection.js";
+import { languages } from "@codemirror/language-data";
+import { classHighlighter, highlightTree } from "@lezer/highlight";
+import { readCodeSettings } from "./code-block.js";
+const element = (tagName, properties, children) => ({ type: "element", tagName, properties, children });
+export function findCodeLanguage(language) {
+    const name = language.toLowerCase();
+    if (!name || ["text", "txt", "plaintext"].includes(name))
+        return undefined;
+    return languages.find(item => item.alias.includes(name) || item.name.toLowerCase() === name || item.name.toLowerCase().replace(/\s+/g, "-") === name || item.extensions.includes(name));
+}
+export async function renderCodeBlock(code, language = "", meta = "") {
+    const settings = readCodeSettings(meta);
+    const lines = [element("span", { className: ["code-line"] }, [])];
+    const append = (value, classes) => {
+        value.split("\n").forEach((part, index) => {
+            if (index)
+                lines.push(element("span", { className: ["code-line"] }, []));
+            if (part)
+                lines.at(-1).children.push(classes ? element("span", { className: classes.split(" ") }, [{ type: "text", value: part }]) : { type: "text", value: part });
+        });
+    };
+    let offset = 0;
+    try {
+        const support = await findCodeLanguage(await resolveCodeLanguage(code, language))?.load();
+        if (support)
+            highlightTree(support.language.parser.parse(code), classHighlighter, (from, to, classes) => {
+                append(code.slice(offset, from));
+                append(code.slice(from, to), classes);
+                offset = to;
+            });
+    }
+    catch { /* Unknown or unavailable grammars still render as readable code. */ }
+    append(code.slice(offset));
+    const children = [element("pre", { tabIndex: 0 }, [element("code", {}, lines.flatMap((line, index) => index ? [{ type: "text", value: "\n" }, line] : [line]))])];
+    if (settings.caption)
+        children.push(element("figcaption", {}, [{ type: "text", value: settings.caption }]));
+    return element("figure", { dataLettercampCode: "", dataCodeWidth: settings.width, dataCodeWrap: String(settings.wrap), dataCodeTheme: settings.theme }, children);
+}
+// Render a custom block node so Markdown and MDX do not add a second pre wrapper.
+export function codeBlocks() {
+    return async (tree) => {
+        const visit = async (node) => {
+            if (node.type === "code") {
+                const block = await renderCodeBlock(node.value ?? "", node.lang ?? "", node.meta ?? "");
+                node.type = "lettercampCode";
+                node.data = { ...node.data, hName: block.tagName, hProperties: block.properties, hChildren: block.children };
+            }
+            await Promise.all((node.children ?? []).map(visit));
+        };
+        await visit(tree);
+    };
+}

package/dist/component-blocks.js

@@ -0,0 +1,32 @@
+// Give standalone components a real layout container without passing editor
+// props to user code. Keep component children opaque and inline JSX inline.
+export function componentBlocks() {
+    return (tree) => {
+        const visit = (parent) => {
+            if (!parent.children)
+                return;
+            parent.children = parent.children.map(node => {
+                if (node.type === "mdxJsxFlowElement") {
+                    if (Array.isArray(node.attributes) && node.attributes.some(attribute => attribute.type === "mdxJsxAttribute" && attribute.name === "data-lettercamp-component"))
+                        return node;
+                    if (!node.name || !/^[a-z][a-z0-9-]*$/.test(node.name))
+                        return wrap(node);
+                }
+                else if (node.type === "mdxFlowExpression" && node.data?.estree?.body.length)
+                    return wrap(node);
+                else if (node.type !== "mdxJsxTextElement")
+                    visit(node);
+                return node;
+            });
+        };
+        visit(tree);
+    };
+}
+function wrap(node) {
+    return {
+        type: "mdxJsxFlowElement", name: "div",
+        attributes: [{ type: "mdxJsxAttribute", name: "data-lettercamp-component", value: "" },
+            { type: "mdxJsxAttribute", name: "data-block-width", value: "regular" }],
+        children: [node],
+    };
+}

package/dist/custom-layout.js

@@ -0,0 +1,32 @@
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+// Generate direct Astro imports so React hydration and CSS imports use the same
+// Vite pipeline as article components. Only the two reserved filenames opt in.
+export async function writeCustomLayout(workspace, contentRoot) {
+    const directory = path.join(contentRoot, 'components');
+    const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    });
+    const sources = ['Header', 'Footer'].map(name => {
+        const matches = entries.filter(entry => (entry.isFile() || entry.isSymbolicLink()) && [name + '.jsx', name + '.tsx'].includes(entry.name));
+        if (matches.length > 1)
+            throw new Error(`Use only one of components/${name}.jsx and components/${name}.tsx.`);
+        const filename = matches[0]?.name;
+        const region = name.toLowerCase();
+        const source = filename
+            ? `---\nimport Component from ${JSON.stringify(path.join(directory, filename).replaceAll('\\', '/'))};\nconst { site, pathname } = Astro.props;\nconst basePath = import.meta.env.BASE_URL.replace(/\\/+$/, '');\n---\n<lettercamp-custom-${region} data-component="${filename}" style="display: contents"><Component site={site} pathname={pathname} basePath={basePath} client:load /></lettercamp-custom-${region}>\n`
+            : `---\nimport Component from './${name}.astro';\n---\n<Component {...Astro.props} />\n`;
+        return { file: path.join(workspace, 'src', 'components', `${name}Slot.astro`), source };
+    });
+    for (const { file, source } of sources) {
+        const previous = await readFile(file, 'utf8').catch((error) => {
+            if (error.code === 'ENOENT')
+                return '';
+            throw error;
+        });
+        if (previous !== source)
+            await writeFile(file, source);
+    }
+}

package/dist/deploy.js

@@ -0,0 +1,131 @@
+import { lstat, readdir, readFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { projectPath, getBinding, saveBinding, readConfig, saveConfig, removeConfig } from './account.js';
+import { ApiError, publishingToken, request, selectHostingSite, status, waitForDeployment } from './hosting.js';
+import { confirm } from './prompts.js';
+const roots = ['pages', 'components', 'lib', 'styles', 'assets'];
+export async function publicationFiles(root) {
+    const files = [];
+    let total = 0;
+    async function visit(relative) {
+        const filename = path.join(root, relative);
+        const info = await lstat(filename);
+        if (info.isSymbolicLink())
+            throw new Error(`Source uploads do not follow symlinks: ${relative}`);
+        if (info.isDirectory()) {
+            for (const entry of (await readdir(filename)).sort()) {
+                if (entry.startsWith('.') || ['node_modules', 'dist', 'build', 'coverage'].includes(entry) || /\.(pem|key|p12|pfx)$/i.test(entry))
+                    continue;
+                await visit(`${relative}/${entry}`);
+            }
+            return;
+        }
+        if (!info.isFile())
+            throw new Error(`Source uploads require regular files: ${relative}`);
+        if (info.size > 5 * 1024 * 1024)
+            throw new Error(`${relative} exceeds 5 MB. Use lettercamp upload for large assets.`);
+        const handle = await open(filename, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        let bytes;
+        try {
+            bytes = await handle.readFile();
+        }
+        finally {
+            await handle.close();
+        }
+        total += bytes.length;
+        if (bytes.length > 5 * 1024 * 1024 || total > 10 * 1024 * 1024 || files.length >= 2000)
+            throw new Error('Source uploads support 2,000 files, 5 MB per file, and 10 MB total. Use lettercamp upload for large assets.');
+        files.push({ path: relative, content: bytes.toString('base64') });
+    }
+    await visit('settings.json');
+    for (const directory of roots) {
+        try {
+            await lstat(path.join(root, directory));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' && directory !== 'pages')
+                continue;
+            throw error;
+        }
+        await visit(directory);
+    }
+    if (!files.some(file => /^pages\/.+\.mdx?$/.test(file.path)))
+        throw new Error('Include at least one Markdown or MDX file in pages/.');
+    JSON.parse(Buffer.from(files.find(file => file.path === 'settings.json').content, 'base64').toString('utf8'));
+    return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+export async function deploy() {
+    const root = await projectPath();
+    // Catch the wrong directory before opening a browser or creating a hosted site.
+    await readFile(path.join(root, 'settings.json'), 'utf8').catch(() => { throw new Error('Run lettercamp deploy inside your publication folder containing settings.json.'); });
+    const files = (await getBinding())?.pending ? null : await publicationFiles(root);
+    const token = await publishingToken();
+    let { site, binding } = await selectHostingSite(token, true);
+    let current = await status(token, site.id, binding.pending);
+    if (!current.managed)
+        throw new Error('This site uses a connected GitHub repository. Push your changes to that repository to publish.');
+    let snapshot;
+    if (binding.pending) {
+        const pending = await readConfig(`deployment-${binding.pending}.json`);
+        if (!pending)
+            throw new Error('The saved upload is missing. Restore your Lettercamp configuration before resuming this deployment.');
+        snapshot = pending;
+        console.error('Resuming the saved deployment. New local edits can be published with the next lettercamp deploy.');
+    }
+    else {
+        if (current.pending) {
+            console.error('Waiting for the current publication to finish…');
+            await waitForDeployment(token, site.id, current.pending);
+            current = await status(token, site.id);
+        }
+        if (!current.revision) {
+            console.error('Finishing site provisioning…');
+            await request(token, `sites/${site.id}/status`, { action: 'retry' });
+            current = await status(token, site.id);
+            if (current.pending)
+                await waitForDeployment(token, site.id, current.pending);
+            current = await status(token, site.id);
+            if (!current.revision)
+                throw new Error('The site repository is not ready. Run lettercamp deploy again shortly.');
+        }
+        if (binding.revision !== current.revision && !binding.fresh) {
+            console.error(binding.revision ? 'The hosted source changed since your last deployment.' : `This folder will replace the publication source on ${site.slug}.lettercamp.site.`);
+            console.error('Local settings, pages, components, lib, styles, and assets replace those remote files, including deletions.');
+            if (!await confirm('Replace the hosted publication with this folder?'))
+                return;
+        }
+        snapshot = { id: randomUUID(), revision: current.revision, files: files ?? await publicationFiles(root) };
+        await saveConfig(`deployment-${snapshot.id}.json`, snapshot);
+        binding = { ...binding, pending: snapshot.id, fresh: undefined };
+        await saveBinding(binding);
+        console.error(`Deploying ${snapshot.files.length} source files to ${site.slug}.lettercamp.site…`);
+    }
+    if (!current.activity || current.activity.id !== snapshot.id) {
+        try {
+            await request(token, `sites/${site.id}/deploy`, snapshot);
+        }
+        catch (error) {
+            // Validation/conflict responses are definitive; network failures retain the upload.
+            if (error instanceof ApiError && [400, 403, 409, 413].includes(error.status)) {
+                binding = { ...binding, pending: undefined };
+                await saveBinding(binding);
+                await removeConfig(`deployment-${snapshot.id}.json`);
+            }
+            throw error;
+        }
+    }
+    const result = await waitForDeployment(token, site.id, snapshot.id, async (activity) => {
+        const revision = activity.sourceCommit && activity.baseRevision ? `${activity.baseRevision.split(':')[0]}:${activity.sourceCommit}` : binding.revision;
+        const finished = ['succeeded', 'failed', 'cancelled'].includes(activity.status);
+        if (revision !== binding.revision || finished) {
+            binding = { ...binding, revision, pending: finished ? undefined : snapshot.id };
+            await saveBinding(binding);
+            if (finished)
+                await removeConfig(`deployment-${snapshot.id}.json`);
+        }
+    });
+    console.log(`Live at ${result.site.url}`);
+}

package/dist/dev.js

@@ -1,12 +1,17 @@
+import { codeBlocks } from "./code-highlight.js";
+import { componentBlocks } from "./component-blocks.js";
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import { dev } from 'astro';
 import mdx from '@astrojs/mdx';
+import react from '@astrojs/react';
 import { unified } from '@astrojs/markdown-remark';
 import { prepareWorkspace } from './workspace.js';
 import { selectDefaultPort } from './ports.js';
 import { readingTime } from './reading-time.js';
-import { updatePublicAsset } from './public-assets.js';
+import { mediaDimensions } from './media-dimensions.js';
+import { reactIntegrationDirectory, reactViteConfig } from './react.js';
+import { writeCustomLayout } from './custom-layout.js';
 export async function startDev(directory, options) {
     // Astro is bundled with Lettercamp; users update it through the Lettercamp CLI.
     process.env.ASTRO_DISABLE_UPDATE_CHECK = 'true';
@@ -44,13 +49,14 @@ export async function startDev(directory, options) {
             root: workspace,
             logLevel: 'warn',
             configFile: false,
-            publicDir: path.join(workspace, 'public'),
+            publicDir: path.join(workspace, '.lettercamp-no-public'),
             output: 'static',
-            integrations: [mdx()],
-            markdown: { processor: unified({ remarkPlugins: [readingTime] }) },
+            integrations: [mdx(), react()],
+            markdown: { syntaxHighlight: false, processor: unified({ remarkPlugins: [readingTime, codeBlocks, componentBlocks, [mediaDimensions, { root: contentRoot }]], rehypePlugins: [[mediaDimensions, { root: contentRoot }]] }) },
             devToolbar: { enabled: false },
             server: { port, host: options.host, open: options.open },
             vite: {
+                ...reactViteConfig,
                 clearScreen: false,
                 logLevel: 'warn',
                 plugins: [{
@@ -70,15 +76,27 @@ export async function startDev(directory, options) {
                             });
                             // Imported files are watched automatically, but external folders
                             // must be registered for newly created pages to be discovered.
-                            vite.watcher.add([path.join(contentRoot, 'pages'), path.join(contentRoot, 'public'), path.join(contentRoot, 'settings.json')]);
-                            vite.watcher.on('all', (event, file) => {
-                                void updatePublicAsset(contentRoot, workspace, file, event).catch(error => {
-                                    vite.config.logger.error(`Unable to update public file: ${error.message}`);
+                            const components = path.join(contentRoot, 'components');
+                            vite.watcher.add([path.join(contentRoot, 'pages'), path.join(contentRoot, 'settings.json'), components]);
+                            let updatingLayout = Promise.resolve();
+                            const updateLayout = (file) => {
+                                if (path.dirname(file) !== components || !/^(Header|Footer)\.(jsx|tsx)$/.test(path.basename(file)))
+                                    return;
+                                updatingLayout = updatingLayout.then(async () => {
+                                    await writeCustomLayout(workspace, contentRoot);
+                                    // Also clear an earlier duplicate-file error when the valid
+                                    // slot source did not change. Add/remove is a rare full reload.
+                                    vite.moduleGraph.invalidateAll();
+                                    vite.ws.send({ type: 'full-reload' });
+                                }).catch(error => {
+                                    vite.config.logger.error(error.message);
+                                    vite.ws.send({ type: 'error', err: { message: error.message, stack: '' } });
                                 });
-                            });
+                            };
+                            vite.watcher.on('add', updateLayout).on('unlink', updateLayout);
                         },
                     }],
-                server: { strictPort: false, fs: { allow: [workspace, contentRoot, modules] } },
+                server: { strictPort: false, fs: { allow: [workspace, contentRoot, modules, reactIntegrationDirectory] } },
             },
         });
         process.once('SIGINT', stop);