@lettercamp/cli 0.1.6 → 0.1.8

package/README.md

@@ -1,3 +1,5 @@
 # Lettercamp CLI
 
-The Lettercamp CLI. See **[lettercamp](https://www.npmjs.com/package/lettercamp)** for more documentation.
+The core package for the [Lettercamp CLI](https://www.npmjs.com/package/lettercamp).
+
+See the **[Lettercamp CLI documentation](https://www.lettercamp.com/docs/cli)** for installation instructions, commands, options, and troubleshooting.

package/dist/account.js

@@ -0,0 +1,189 @@
+import { chmod, mkdir, readFile, realpath, rename, rm, writeFile, access } from 'node:fs/promises';
+import { homedir, hostname } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+const configRoot = () => process.env.LETTERCAMP_CONFIG_DIR || path.join(process.platform === 'win32' ? process.env.APPDATA || path.join(homedir(), 'AppData', 'Roaming') : process.env.XDG_CONFIG_HOME || path.join(homedir(), '.config'), 'lettercamp');
+export function apiOrigin() {
+    const url = new URL(process.env.LETTERCAMP_API_URL || 'https://www.lettercamp.com');
+    const local = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+    if ((url.protocol !== 'https:' && !(local && url.protocol === 'http:')) || url.username || url.password || url.pathname !== '/' || url.search || url.hash) {
+        throw new Error('LETTERCAMP_API_URL must be an HTTPS origin (HTTP is allowed for localhost development).');
+    }
+    return url.origin;
+}
+export async function readConfig(name) {
+    try {
+        return JSON.parse(await readFile(path.join(configRoot(), name), 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new Error(`Unable to read Lettercamp ${name}. Check ${configRoot()}.`);
+    }
+}
+export async function saveConfig(name, value) {
+    await mkdir(configRoot(), { recursive: true, mode: 0o700 });
+    if (process.platform !== 'win32')
+        await chmod(configRoot(), 0o700);
+    const temporary = path.join(configRoot(), `.${name}-${randomUUID()}`);
+    try {
+        await writeFile(temporary, JSON.stringify(value, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        await rename(temporary, path.join(configRoot(), name));
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function credentials() {
+    const saved = await readConfig('credentials.json');
+    if (!saved || saved.origin !== apiOrigin() || typeof saved.token !== 'string' || !/^lc_[a-f0-9]{64}$/.test(saved.token)) {
+        throw new Error('Run lettercamp login to sign in to this server.');
+    }
+    return saved;
+}
+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(timeout) });
+    }
+    catch {
+        throw new Error('Unable to reach Lettercamp. Check your connection and try again.');
+    }
+}
+export async function responseJson(response) {
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch {
+        throw new Error(`Lettercamp returned an unexpected response (HTTP ${response.status}).`);
+    }
+    if (!response.ok) {
+        if (response.status === 401)
+            throw new Error('Your CLI session expired or was revoked. Run lettercamp login again.');
+        const problem = result;
+        throw new Error(typeof problem?.message === 'string' ? problem.message : typeof problem?.error === 'string' ? problem.error : `Request failed (HTTP ${response.status}).`);
+    }
+    return result;
+}
+async function openBrowser(url) {
+    const [command, args] = process.platform === 'darwin' ? ['open', [url]]
+        : process.platform === 'win32' ? ['rundll32', ['url.dll,FileProtocolHandler', url]] : ['xdg-open', [url]];
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], { stdio: 'ignore', shell: false });
+        child.once('error', reject);
+        child.once('exit', code => code === 0 ? resolve() : reject(new Error('Browser could not open.')));
+    });
+}
+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, 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.');
+    console.error(`Your code: ${login.user_code}\nOpen ${verification.href}\nConfirm the matching code in your browser. Waiting for approval…`);
+    if (options.browser)
+        await openBrowser(verification.href).catch(() => console.error('Open the link above in a browser to continue.'));
+    const deadline = Date.now() + Math.min(login.expires_in, 600) * 1000;
+    let interval = Math.max(5, login.interval) * 1000;
+    while (Date.now() < deadline) {
+        await new Promise(resolve => setTimeout(resolve, interval));
+        if (Date.now() >= deadline)
+            break;
+        const response = await apiRequest('/api/cli/token', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ device_code: login.device_code }) });
+        const body = await response.json();
+        if (body.error === 'authorization_pending')
+            continue;
+        if (body.error === 'slow_down') {
+            interval = Math.min(interval + 5000, 30000);
+            continue;
+        }
+        if (body.error === 'access_denied')
+            throw new Error('Login was denied in the browser.');
+        if (body.error === 'expired_token')
+            throw new Error('Login expired or was already completed. Run lettercamp login again.');
+        if (!response.ok || !body.access_token || !/^lc_[a-f0-9]{64}$/.test(body.access_token) || !body.expires_at || !body.user)
+            throw new Error(body.message || 'Unable to finish login. Run lettercamp login again.');
+        try {
+            await saveConfig('credentials.json', { origin: apiOrigin(), token: body.access_token, expiresAt: body.expires_at, user: body.user });
+        }
+        catch {
+            await apiRequest('/api/cli/session', { method: 'DELETE' }, body.access_token).catch(() => undefined);
+            throw new Error('Unable to save the CLI credential. Check your configuration directory permissions and run lettercamp login again.');
+        }
+        if (previous?.origin === apiOrigin() && /^lc_[a-f0-9]{64}$/.test(previous.token)) {
+            try {
+                const revoked = await apiRequest('/api/cli/session', { method: 'DELETE' }, previous.token);
+                if (!revoked.ok && revoked.status !== 401)
+                    throw new Error();
+            }
+            catch {
+                console.error('Previous session could not be revoked. You can revoke it from your account page.');
+            }
+        }
+        console.log(`Signed in as ${body.user.email}.`);
+        return;
+    }
+    throw new Error('Login timed out. Run lettercamp login again.');
+}
+export async function whoami(options) {
+    const saved = await credentials();
+    const user = await responseJson(await apiRequest('/api/cli/session', {}, saved.token));
+    console.log(options.json ? JSON.stringify(user) : `${user.name} <${user.email}>`);
+}
+export async function logout() {
+    const saved = await readConfig('credentials.json');
+    if (!saved) {
+        console.log('Already signed out.');
+        return;
+    }
+    if (saved.origin !== apiOrigin())
+        throw new Error(`This credential belongs to ${saved.origin}. Set LETTERCAMP_API_URL to that origin to sign out.`);
+    const response = await apiRequest('/api/cli/session', { method: 'DELETE' }, saved.token);
+    if (!response.ok && response.status !== 401)
+        await responseJson(response);
+    await rm(path.join(configRoot(), 'credentials.json'), { force: true });
+    console.log('Signed out.');
+}
+export async function projectPath() {
+    const cwd = await realpath(process.cwd());
+    for (let directory = cwd;; directory = path.dirname(directory)) {
+        try {
+            await access(path.join(directory, 'settings.json'));
+            return directory;
+        }
+        catch { /* Walk up to the publication root. */ }
+        if (path.dirname(directory) === directory)
+            return cwd;
+    }
+}
+export async function selectUploadSite(token, requested) {
+    const { sites } = await responseJson(await apiRequest('/api/cli/sites', {}, token));
+    const project = await projectPath();
+    const bindings = await readConfig('sites.json') ?? {};
+    const binding = bindings[project];
+    const selected = requested || (binding?.origin === apiOrigin() ? binding.siteId : undefined);
+    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. 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: () => 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,38 +1,53 @@
+import { publicationLinks } from './publication-links.js';
+import { codeBlocks } from "./code-highlight.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, contentRoot, cleanup } = await prepareWorkspace(root);
+    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(contentRoot, 'public'), outDir, output: 'static',
-            integrations: [mdx()],
+            publicDir: path.join(workspace, '.lettercamp-no-public'), outDir, output: 'static',
+            integrations: [mdx(), react()],
+            vite: reactViteConfig,
+            markdown: { syntaxHighlight: false, processor: unified({ remarkPlugins: [readingTime, codeBlocks, [mediaDimensions, { root }], [publicationLinks, { basePath: origin.pathname }]], rehypePlugins: [[mediaDimensions, { root }]] }) },
             build: { format: 'directory', ...(options.assetsPrefix ? { assetsPrefix: options.assetsPrefix } : {}) },
-            vite: { resolve: { alias: {
-                        home: path.join(workspace, 'src/layouts/Content.astro'),
-                        post: path.join(workspace, 'src/layouts/Content.astro'),
-                    } } },
         });
         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

@@ -1,10 +1,30 @@
 import { Command, InvalidArgumentError } from 'commander';
 import { version, showVersion, update } from './version.js';
+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 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); });
+    program.command('whoami')
+        .description('Show the signed-in account')
+        .option('--json', 'Print account details as JSON')
+        .action(async (options) => { const { whoami } = await import('./account.js'); await whoami(options); });
+    program.command('logout')
+        .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 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 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')
@@ -12,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);
@@ -20,7 +48,7 @@ export async function run(argv = process.argv) {
         .action(update);
     program.command('dev')
         .description('Preview the current publication with live reload')
-        .option('-p, --port <number>', 'Local port', (value) => {
+        .option('-p, --port <number>', 'Preferred local port (tries the next available port if busy)', (value) => {
         if (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 65535) {
             throw new InvalidArgumentError('Use a port between 1 and 65535.');
         }
@@ -28,9 +56,11 @@ export async function run(argv = process.argv) {
     }, 3000)
         .option('--host <address>', 'Host to listen on', 'localhost')
         .option('--open', 'Open the preview in your browser', false)
-        .action(async (options) => {
-        const { startDev } = await import('./dev.js');
-        await startDev(process.cwd(), options);
+        .action(async (options, command) => {
+        await preview(process.cwd(), {
+            ...options,
+            useDefaultPorts: command.getOptionValueSource('port') === 'default',
+        });
     });
     program.command('build')
         .description('Build a static publication for hosting')

package/dist/code-block.js

@@ -0,0 +1,50 @@
+// Generated from lettercamp/lib/code-block.ts. Run pnpm sync:renderer in the app repository.
+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. Run pnpm sync:renderer in the app repository.
+// 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. Run pnpm sync:renderer in the app repository.
+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/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}`);
+}