sbuilder-mcp 0.1.0

package/dist/domains/site/review.js

@@ -0,0 +1,141 @@
+import { childrenOf, isOverlay, pageChildren } from '../../core/tree.js';
+import { ELEMENTS, BINDING_SOURCES } from '../../catalog/elements.generated.js';
+/**
+ * Shipped with every non-empty finding list.
+ *
+ * The sibling `webcake-landing-mcp` learned this the hard way and says so in its
+ * own source: without a directive, models read warnings as advisory noise and
+ * save anyway. These are not suggestions — each one is something a customer
+ * loads the page and sees.
+ */
+export const REVIEW_NOTICE = 'FIX THESE. Each one is a defect a visitor will see on the published page, not a ' +
+    'suggestion — a blank band, a placeholder sentence, a broken image. Apply the fix each ' +
+    'finding names, then review again until the list is empty. Do not report the page as done ' +
+    'while findings stand; if you believe one is a false positive, say which and why.';
+/** The specials keys an element seeds that hold its visible content. */
+function contentKeys(type) {
+    const seeded = ELEMENTS[type]?.defaults.specials ?? {};
+    return Object.keys(seeded).filter((k) => k === 'text' || k === 'src' || k === 'url');
+}
+function seededValue(type, key) {
+    return (ELEMENTS[type]?.defaults.specials ?? {})[key];
+}
+/**
+ * Everything wrong with this page that a person would notice.
+ *
+ * Overlays are skipped: the cart drawer is composed onto ROOT on read and is not
+ * this page's to fix. Findings are ordered by document order so a caller working
+ * top-down meets them in the order they appear on screen.
+ */
+export function reviewDesign(doc) {
+    const d = doc.doc;
+    const out = [];
+    const overlayIds = new Set(childrenOf(d, d.root_node_id).filter((id) => isOverlay(d, id)));
+    if (pageChildren(d).length === 0) {
+        out.push({
+            code: 'empty_page',
+            nodeId: d.root_node_id,
+            type: 'root',
+            problem: 'The page has no content — it publishes as a blank document.',
+            fix: 'Add a section with sb_add (parent_id ROOT, type flex-section), or drop a designed one in with sb_template_use.',
+        });
+        return out;
+    }
+    // Document order, depth-first from ROOT: the order a reader meets them.
+    const seen = new Set();
+    const walkOrder = [];
+    const go = (id) => {
+        if (seen.has(id) || overlayIds.has(id))
+            return;
+        seen.add(id);
+        walkOrder.push(id);
+        for (const k of childrenOf(d, id))
+            go(k);
+    };
+    go(d.root_node_id);
+    for (const id of walkOrder) {
+        if (id === d.root_node_id)
+            continue;
+        const n = d.nodes[id];
+        const type = n.data.type;
+        const meta = ELEMENTS[type];
+        if (!meta) {
+            out.push({
+                code: 'unknown_element',
+                nodeId: id,
+                type,
+                problem: `"${type}" is not an element this catalog knows, so nothing can say how it renders.`,
+                fix: 'Regenerate the catalog (npm run codegen against a current web_builder checkout). If the element was removed from the platform, delete the node with sb_remove.',
+            });
+            continue;
+        }
+        // A container with nothing in it is a band of empty space. The commonest way
+        // to ship one is to add the section and then get distracted.
+        if (meta.isContainer && childrenOf(d, id).length === 0) {
+            out.push({
+                code: 'empty_container',
+                nodeId: id,
+                type,
+                problem: 'This container holds nothing — it renders as an empty band.',
+                fix: `Add something inside it (sb_add with parent_id "${id}"), or remove it with sb_remove.`,
+            });
+        }
+        for (const key of contentKeys(type)) {
+            const value = (n.specials ?? {})[key];
+            const seed = seededValue(type, key);
+            const isBlank = value === undefined || value === null || String(value).trim() === '';
+            if (isBlank) {
+                // An element that seeds a blank (image.src is "") is not misconfigured —
+                // it is unfinished, and it renders as a gap or a broken frame.
+                out.push({
+                    code: key === 'text' ? 'empty_text' : 'missing_media',
+                    nodeId: id,
+                    type,
+                    problem: key === 'text'
+                        ? 'This element has no text — it renders as empty space.'
+                        : `This element has no ${key} — it renders as a broken or missing image.`,
+                    fix: `Set it: sb_set id "${id}", namespace specials, keys { "${key}": … }.`,
+                });
+                continue;
+            }
+            // Content still equal to the element's OWN seeded default is the author's
+            // placeholder, published. "Enter your text here" on a live page is the
+            // single most visible way this goes wrong, and it is invisible to every
+            // structural check because the document is perfectly well-formed.
+            if (seed !== undefined && String(seed).trim() !== '' && value === seed) {
+                out.push({
+                    code: 'placeholder_content',
+                    nodeId: id,
+                    type,
+                    problem: `Still the placeholder the element ships with (${JSON.stringify(seed)}).`,
+                    fix: `Write the real copy: sb_set id "${id}", namespace specials, keys { "${key}": … }.`,
+                });
+            }
+        }
+        // A binding whose source the renderer does not provide resolves to nothing,
+        // and the element falls back to its own placeholder — indistinguishable, on
+        // screen, from data that has not loaded.
+        for (const b of n
+            .bindings ?? []) {
+            if (b.source && !BINDING_SOURCES.includes(b.source)) {
+                out.push({
+                    code: 'dead_binding',
+                    nodeId: id,
+                    type,
+                    problem: `Bound to "${b.source}", which the renderer does not provide — it will show the placeholder forever.`,
+                    fix: `Rebind with sb_bind using one of: ${BINDING_SOURCES.join(', ')}.`,
+                });
+            }
+            if (b.field && !b.field.startsWith('specials.')) {
+                out.push({
+                    code: 'dead_binding',
+                    nodeId: id,
+                    type,
+                    problem: `Binds into "${b.field}"; the renderer only applies bindings under "specials".`,
+                    fix: `Rebind with sb_bind and a field of the form "specials.<key>".`,
+                });
+            }
+        }
+    }
+    return out;
+}

package/dist/domains/site/traps.js

@@ -0,0 +1,98 @@
+import { pageChildren, isOverlay, SPEC_GLOBAL_ID, SPEC_GLOBAL_KIND, } from '../../core/tree.js';
+/**
+ * Which band a direct child of ROOT belongs to.
+ *
+ * An unstamped section lives in the middle; a global's band comes from its
+ * `globalKind`. An UNRECOGNISED kind is middle rather than an error, matching
+ * the platform's own `bandOf` — a document storing a kind we do not know is
+ * still a document that must open.
+ */
+export function bandOf(doc, id) {
+    const n = doc.nodes[id];
+    if (!n || n.specials?.[SPEC_GLOBAL_ID] === undefined)
+        return 'middle';
+    const kind = `${n.specials[SPEC_GLOBAL_KIND] ?? ''}`;
+    if (kind === 'header' || kind === 'footer')
+        return kind;
+    return 'middle';
+}
+/**
+ * THE BAND RULE: ROOT's children must read [header*][middle*][footer*].
+ *
+ * The platform enforces this on EVERY save (`checkBands` in
+ * server/internal/page/decompose.go), so a document that breaks it cannot be
+ * stored at all — the author gets `ErrBandOrder` and loses the write. Checking
+ * it here means the builder refuses to construct the violation, rather than
+ * discovering it one autosave later with a tree nobody will ever store.
+ *
+ * Ordinary sections are constrained too, not just globals: once a page has a
+ * global header, nothing may sit above it, or the "header" stops being one.
+ *
+ * Overlays are excluded, because the platform strips them BEFORE it checks —
+ * that ordering is why the band rule needs no overlay exception, and copying
+ * the ordering is why ours needs none either.
+ *
+ * Returns null when the order is legal, or a sentence naming the offender.
+ */
+export function checkBandOrder(doc) {
+    let phase = 'header';
+    for (const id of pageChildren(doc)) {
+        const band = bandOf(doc, id);
+        if (band === 'header') {
+            if (phase !== 'header') {
+                return `Node ${id} is a global header but sits after ${phase} content. ROOT's children must read header, then middle, then footer — the platform refuses every save otherwise.`;
+            }
+        }
+        else if (band === 'footer') {
+            phase = 'footer';
+        }
+        else {
+            if (phase === 'footer') {
+                return `Node ${id} is ordinary content but sits after a global footer. ROOT's children must read header, then middle, then footer — the platform refuses every save otherwise.`;
+            }
+            phase = 'middle';
+        }
+    }
+    return null;
+}
+/** Is this node a composed GLOBAL SECTION master — a shared header or footer? */
+export function isGlobal(doc, id) {
+    return doc.nodes[id]?.specials?.[SPEC_GLOBAL_ID] !== undefined;
+}
+/**
+ * The sentence to attach to any result that touched a global.
+ *
+ * Editing a master is not a page-local act: it changes every page carrying that
+ * section, and publishing one cascades to those pages — a header edited once
+ * must not go live on one page and stay stale on the rest. An agent that does
+ * not know this reports "updated the header" having changed the whole site.
+ */
+export function globalWarning(doc, id) {
+    if (!isGlobal(doc, id))
+        return null;
+    const gid = doc.nodes[id].specials[SPEC_GLOBAL_ID];
+    return `Node ${id} is the shared global section ${JSON.stringify(gid)}. Editing it changes EVERY page that carries it, and publishing cascades to all of them. Say so when reporting this change.`;
+}
+/**
+ * Keys that are identity or content rather than a visual quantity.
+ *
+ * Kept as a hint for callers deciding where a value belongs — NOT as a gate. An
+ * earlier version of this file claimed base-only values "vanish on publish" and
+ * `setKeys` refused them; both were wrong. The published cascade has a base
+ * layer (style/cascade.go MergeNamespace: current slot → wider → BASE →
+ * narrower), and every element's meta.defaults seeds into it.
+ *
+ * The platform's responsive mandate is about ELEMENT IMPLEMENTATION — a renderer
+ * reading `n.Config[...]` directly bypasses that cascade, which is what makes a
+ * per-breakpoint value unreachable at publish. Nothing a document stores can
+ * cause it.
+ */
+const IDENTITY_KEYS = new Set(['htmlTag', 'kind', 'name', 'id', 'type', 'href', 'src', 'alt']);
+export function isIdentityKey(key) {
+    return IDENTITY_KEYS.has(key);
+}
+export const RESPONSIVE_NOTICE = 'Written per breakpoint, which is the default because a design should respond. Base is ' +
+    'legitimate too — it is the cascade\'s fallback layer, below every breakpoint slot, and ' +
+    'where an element\'s own defaults live. Use base for a value that genuinely should not ' +
+    'vary; use a breakpoint for anything a narrower screen should change.';
+export { isOverlay };

package/dist/domains/site/validate.js

@@ -0,0 +1,49 @@
+import { childrenOf, subtreeIds } from '../../core/tree.js';
+import { checkBandOrder } from './traps.js';
+/**
+ * Everything that would make the platform refuse this document on save.
+ *
+ * Each check mirrors one the server runs. Running them here turns a silent
+ * failure — an autosave rejected twenty minutes ago, with the agent still
+ * happily editing a tree nobody will ever store — into a refusal at the call
+ * that caused it.
+ *
+ * Returns an empty array when the document is storable.
+ */
+export function validateForSave(doc) {
+    const d = doc.doc;
+    const problems = [];
+    const band = checkBandOrder(d);
+    if (band)
+        problems.push(band);
+    // Dangling child ids: a parent naming a node that is not in the map. The
+    // renderer walks children by id, so this is a hole in the rendered page.
+    for (const [id, n] of Object.entries(d.nodes)) {
+        for (const kid of n.data.nodes) {
+            if (!d.nodes[kid]) {
+                problems.push(`Node ${id} lists child "${kid}", which is not in the document.`);
+            }
+        }
+    }
+    // Parent pointers that disagree with the child lists. BOTH are stored, and the
+    // renderer trusts the child list while a move trusts the pointer — so a
+    // disagreement renders one tree and edits another.
+    for (const [id, n] of Object.entries(d.nodes)) {
+        if (id === d.root_node_id)
+            continue;
+        const p = n.data.parent;
+        if (p && d.nodes[p] && !childrenOf(d, p).includes(id)) {
+            problems.push(`Node ${id} claims parent ${p}, but ${p} does not list it as a child.`);
+        }
+    }
+    // Orphans: reachable from nobody. They bloat every save and never render.
+    // Walking from ROOT covers overlays too — they are composed onto ROOT's child
+    // list, so they are reachable and correctly not reported here.
+    const reachable = new Set(subtreeIds(d, d.root_node_id));
+    for (const id of Object.keys(d.nodes)) {
+        if (!reachable.has(id)) {
+            problems.push(`Node ${id} is unreachable from ROOT — nothing references it.`);
+        }
+    }
+    return problems;
+}

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer } from './server.js';
+import { runInstallCli } from './install/index.js';
+async function main() {
+    // `sbuilder-mcp install` writes this server into the agent clients on this
+    // machine and exits. Checked BEFORE the transport opens: an installer that
+    // also spoke MCP on stdout would corrupt the protocol for whatever ran it.
+    if (process.argv[2] === 'install') {
+        process.exit(runInstallCli(process.argv.slice(3)));
+    }
+    const server = createServer();
+    await server.connect(new StdioServerTransport());
+    // stdout is the MCP channel. Every log line in this repo is console.error.
+    console.error('[sbuilder-mcp] ready on stdio');
+}
+main().catch((err) => {
+    console.error('[sbuilder-mcp] fatal:', err);
+    process.exit(1);
+});

package/dist/install/index.js

@@ -0,0 +1,108 @@
+import { targets, detected } from './paths.js';
+import { mergeInto } from './write.js';
+/** The name the server appears under in every client. */
+export const SERVER_NAME = 'sbuilder';
+export function buildEntry(opts, pkg = 'sbuilder-mcp') {
+    const env = {};
+    if (opts.api)
+        env.SB_API = opts.api;
+    if (opts.token)
+        env.SB_TOKEN = opts.token;
+    // Only when a key is absent: a key opens everything the agent does day to day,
+    // and writing an account password into six config files to buy the handful of
+    // account-level calls it adds is a bad trade the installer should not make for
+    // someone.
+    if (!opts.token && opts.email)
+        env.SB_EMAIL = opts.email;
+    if (!opts.token && opts.password)
+        env.SB_PASSWORD = opts.password;
+    return { command: 'npx', args: ['-y', pkg], env };
+}
+export function chooseTargets(opts) {
+    const all = targets(opts.home);
+    if (opts.clients && opts.clients.length > 0) {
+        const wanted = new Set(opts.clients.map((c) => c.trim().toLowerCase()));
+        const picked = all.filter((t) => wanted.has(t.id));
+        const unknown = [...wanted].filter((w) => !all.some((t) => t.id === w));
+        if (unknown.length) {
+            throw new Error(`sbuilder: unknown client(s) ${unknown.join(', ')}. Known: ${all.map((t) => t.id).join(', ')}.`);
+        }
+        return picked;
+    }
+    return detected(all);
+}
+/**
+ * Write the server into every chosen client.
+ *
+ * One client failing never stops the others: a broken Cursor config is no reason
+ * to leave Claude Code unconfigured, and the report says which is which. The
+ * token is never echoed — the result names files, not secrets.
+ */
+export function install(opts) {
+    const entry = buildEntry(opts);
+    return chooseTargets(opts).map((t) => {
+        if (opts.dryRun) {
+            return { client: t.label, path: t.path, status: 'skipped', reason: 'dry run', note: t.note };
+        }
+        try {
+            const out = mergeInto(t, SERVER_NAME, entry);
+            return {
+                client: t.label,
+                path: t.path,
+                status: out.wrote ? 'installed' : 'unchanged',
+                ...(out.reason ? { reason: out.reason } : {}),
+                ...(out.backup ? { backup: out.backup } : {}),
+                ...(out.wrote && t.note ? { note: t.note } : {}),
+            };
+        }
+        catch (err) {
+            return { client: t.label, path: t.path, status: 'skipped', reason: String(err) };
+        }
+    });
+}
+/** `sbuilder-mcp install --token wbk_… --api https://…` */
+export function runInstallCli(argv) {
+    const get = (flag) => {
+        const i = argv.indexOf(flag);
+        return i >= 0 ? argv[i + 1] : undefined;
+    };
+    const opts = {
+        token: get('--token') ?? process.env.SB_TOKEN,
+        api: get('--api') ?? process.env.SB_API,
+        email: get('--email') ?? process.env.SB_EMAIL,
+        password: get('--password') ?? process.env.SB_PASSWORD,
+        clients: get('--client')?.split(','),
+        dryRun: argv.includes('--dry-run'),
+    };
+    if (!opts.token && !(opts.email && opts.password)) {
+        console.error('sbuilder: nothing to install with.\n' +
+            '  Get a key from your store: Apps → AI agent → Create key, then\n' +
+            '    npx -y sbuilder-mcp install --token wbk_… --api https://your-host\n');
+        return 1;
+    }
+    let results;
+    try {
+        results = install(opts);
+    }
+    catch (err) {
+        console.error(`sbuilder: ${err.message}`);
+        return 1;
+    }
+    if (results.length === 0) {
+        console.error('sbuilder: no agent client found on this machine.\n' +
+            `  Name one explicitly: --client ${targets().map((t) => t.id).join(',')}`);
+        return 1;
+    }
+    for (const r of results) {
+        const mark = r.status === 'installed' ? '✔' : r.status === 'unchanged' ? '·' : '✖';
+        console.error(`${mark} ${r.client} — ${r.status}${r.reason ? ` (${r.reason})` : ''}`);
+        console.error(`    ${r.path}`);
+        // The undo, named. A config writer that changes a file without saying where
+        // the old one went leaves the user with nothing to reach for.
+        if (r.backup)
+            console.error(`    previous file saved as ${r.backup}`);
+        if (r.note)
+            console.error(`    ${r.note}`);
+    }
+    return results.some((r) => r.status === 'installed' || r.status === 'unchanged') ? 0 : 1;
+}

package/dist/install/paths.js

@@ -0,0 +1,83 @@
+import { existsSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+const PLAT = platform();
+/**
+ * `home` is a PARAMETER, not a constant read at import time.
+ *
+ * It exists because a test of a config writer must not be able to reach the real
+ * one, and a module-level `homedir()` makes that impossible to guarantee: a
+ * `HOME=` prefix does not reliably reach `os.homedir()`, which I proved the
+ * expensive way — a "sandboxed" run wrote an entry into this machine's actual
+ * Cursor config. Passing the directory in removes the possibility rather than
+ * relying on an env var behaving.
+ */
+export function targets(home = homedir()) {
+    const HOME = home;
+    const APPDATA = process.env.APPDATA || join(HOME, 'AppData', 'Roaming');
+    const claudeDesktopDir = PLAT === 'win32'
+        ? join(APPDATA, 'Claude')
+        : existsSync(join(HOME, 'Library', 'Application Support', 'Claude'))
+            ? join(HOME, 'Library', 'Application Support', 'Claude')
+            : join(HOME, '.config', 'Claude');
+    const vscodeUserDir = PLAT === 'win32'
+        ? join(APPDATA, 'Code', 'User')
+        : existsSync(join(HOME, 'Library', 'Application Support', 'Code', 'User'))
+            ? join(HOME, 'Library', 'Application Support', 'Code', 'User')
+            : join(HOME, '.config', 'Code', 'User');
+    return [
+        {
+            id: 'claude-code',
+            label: 'Claude Code',
+            format: 'json',
+            path: join(HOME, '.claude.json'),
+            key: 'mcpServers',
+            note: 'Open a new session to pick it up.',
+        },
+        {
+            id: 'claude-desktop',
+            label: 'Claude Desktop',
+            format: 'json',
+            path: join(claudeDesktopDir, 'claude_desktop_config.json'),
+            key: 'mcpServers',
+            note: 'Quit and reopen Claude Desktop.',
+        },
+        {
+            id: 'cursor',
+            label: 'Cursor',
+            format: 'json',
+            path: join(HOME, '.cursor', 'mcp.json'),
+            key: 'mcpServers',
+            note: 'Restart Cursor.',
+        },
+        {
+            id: 'windsurf',
+            label: 'Windsurf',
+            format: 'json',
+            path: join(HOME, '.codeium', 'windsurf', 'mcp_config.json'),
+            key: 'mcpServers',
+            note: 'Restart Windsurf.',
+        },
+        {
+            id: 'vscode',
+            label: 'VS Code',
+            format: 'json',
+            path: join(vscodeUserDir, 'mcp.json'),
+            // VS Code is the one that did not follow `mcpServers`.
+            key: 'servers',
+            note: 'Reload the window.',
+        },
+        {
+            id: 'codex',
+            label: 'Codex',
+            format: 'toml',
+            path: join(HOME, '.codex', 'config.toml'),
+            key: 'mcp_servers',
+            note: 'Restart Codex.',
+        },
+    ];
+}
+/** The clients this machine appears to have — a config file or its folder exists. */
+export function detected(all = targets()) {
+    return all.filter((t) => existsSync(t.path) || existsSync(join(t.path, '..')));
+}

package/dist/install/write.js

@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+/**
+ * Add or replace ONE server inside a client's config, leaving everything else
+ * exactly as it was.
+ *
+ * MERGE, never write: these are the user's own files and they hold other
+ * people's servers. A whole-file write is the difference between installing a
+ * server and deleting somebody's setup — and they would only find out the next
+ * time they reached for a tool that had quietly gone.
+ *
+ * A malformed existing file is REFUSED rather than replaced. It is far more
+ * likely to be a config with a trailing comma than one worth discarding, and
+ * overwriting it destroys the very thing the user would need to fix it.
+ */
+export function mergeJson(target, name, entry) {
+    let doc = {};
+    if (existsSync(target.path)) {
+        const raw = readFileSync(target.path, 'utf8').trim();
+        if (raw) {
+            try {
+                doc = JSON.parse(raw);
+            }
+            catch {
+                return {
+                    wrote: false,
+                    reason: `${target.path} is not valid JSON. Refusing to overwrite it — fix or move it, then run this again.`,
+                };
+            }
+        }
+    }
+    const servers = (doc[target.key] ?? {});
+    const before = JSON.stringify(servers[name] ?? null);
+    servers[name] = entry;
+    doc[target.key] = servers;
+    // Idempotent: an identical entry is not a write, so re-running the installer
+    // does not churn a file or leave a pointless backup behind.
+    if (before === JSON.stringify(entry))
+        return { wrote: false, reason: 'already configured' };
+    let backup;
+    if (existsSync(target.path)) {
+        backup = `${target.path}.sbuilder-backup`;
+        copyFileSync(target.path, backup);
+    }
+    mkdirSync(dirname(target.path), { recursive: true });
+    writeFileSync(target.path, JSON.stringify(doc, null, 2) + '\n');
+    return { wrote: true, backup };
+}
+/**
+ * The same job for Codex, which uses TOML.
+ *
+ * Hand-written rather than pulling in a TOML library: the block this writes is
+ * three known keys, and the file is edited by REPLACING the `[mcp_servers.<name>]`
+ * table if it is there and appending it if it is not. A parser would let us
+ * rewrite the whole document, which is exactly what the merge rule above forbids
+ * — a reformatted file is a diff the user did not ask for, across settings this
+ * tool has no business touching.
+ */
+export function mergeToml(target, name, entry) {
+    const header = `[${target.key}.${name}]`;
+    const env = Object.entries(entry.env)
+        .map(([k, v]) => `${k} = ${JSON.stringify(v)}`)
+        .join(', ');
+    const block = `${header}\n` +
+        `command = ${JSON.stringify(entry.command)}\n` +
+        `args = [${entry.args.map((a) => JSON.stringify(a)).join(', ')}]\n` +
+        (env ? `env = { ${env} }\n` : '');
+    let existing = '';
+    if (existsSync(target.path))
+        existing = readFileSync(target.path, 'utf8');
+    // Replace from our header up to the next table header, or to the end.
+    const start = existing.indexOf(header);
+    let next;
+    if (start === -1) {
+        next = existing.trimEnd() ? `${existing.trimEnd()}\n\n${block}` : block;
+    }
+    else {
+        const after = existing.indexOf('\n[', start + 1);
+        const tail = after === -1 ? '' : existing.slice(after + 1);
+        next = existing.slice(0, start) + block + (tail ? `\n${tail}` : '');
+    }
+    if (next === existing)
+        return { wrote: false, reason: 'already configured' };
+    let backup;
+    if (existsSync(target.path)) {
+        backup = `${target.path}.sbuilder-backup`;
+        copyFileSync(target.path, backup);
+    }
+    mkdirSync(dirname(target.path), { recursive: true });
+    writeFileSync(target.path, next);
+    return { wrote: true, backup };
+}
+export function mergeInto(target, name, entry) {
+    return target.format === 'toml'
+        ? mergeToml(target, name, entry)
+        : mergeJson(target, name, entry);
+}