@inditextech/docouture-cli 0.1.0-SNAPSHOT.40.1

package/build/lib/copy-template.js

@@ -0,0 +1,162 @@
+'use strict';
+import { readdir, readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+const PLACEHOLDERS = {
+    __DOCOUTURE_NAME__: 'name',
+    __DOCOUTURE_TITLE__: 'title',
+    __DOCOUTURE_COMPONENT_NAME__: 'componentName',
+    __DOCOUTURE_CLI_VERSION__: 'cliVersion',
+    __DOCOUTURE_PM__: 'pmName',
+    __DOCOUTURE_PM_CACHE__: 'pmCacheName',
+    __DOCOUTURE_LOCKFILE__: 'pmLockfile',
+    __DOCOUTURE_INSTALL_CI__: 'pmCiCmd',
+    // The whole comment line (leading spaces, `#`, trailing newline) is the
+    // token here, not just the bare placeholder name — a bare
+    // `__DOCOUTURE_PM_SETUP_STEP__` sitting at the start of a YAML line with a
+    // step's own `- name: …` right after it on the same line is not valid YAML
+    // on its own (before substitution), which is exactly the form these
+    // template files are in until `docouture new` runs — and `just fmt`/prettier
+    // parses them as real YAML. A `#`-prefixed placeholder is a comment,
+    // valid on any line, so the *template* stays parseable; substituting the
+    // whole line (not just the token inside it) is what lets the pnpm-only
+    // value (which ends in its own `\n` — see packageManagerPlan) or the
+    // empty npm value drop cleanly in its place.
+    '      # __DOCOUTURE_PM_SETUP_STEP__\n': 'pmSetupStepYaml',
+    // A bare token this time, unlike pmSetupStepYaml above — see
+    // TemplateValues.repoIgnoreGlob's own comment for why the whole-segment
+    // trick doesn't survive here.
+    __DOCOUTURE_REPO_IGNORE_GLOB__: 'repoIgnoreGlob',
+};
+// `<!-- prettier-ignore -->` directives exist only to stop prettier mangling a
+// placeholder token in the template source (e.g. `__DOCOUTURE_TITLE__` inside a
+// markdown heading, which double-underscore emphasis would otherwise rewrite
+// to `**DOCOUTURE_TITLE**`) — they are not meant to survive into scaffolded
+// output, where the placeholder has already been substituted away.
+const PRETTIER_IGNORE_LINE = /^<!-- prettier-ignore -->\n/m;
+function substitute(text, values) {
+    let out = text.replace(PRETTIER_IGNORE_LINE, '');
+    for (const [token, key] of Object.entries(PLACEHOLDERS)) {
+        out = out.split(token).join(values[key]);
+    }
+    return out;
+}
+// A `.versioned` marker in a template filename (e.g.
+// `antora-playbook.versioned.yml` beside `antora-playbook.yml`, or
+// `release-version.versioned` for a file with no natural extension to hang a
+// mid-name marker off) is a versioning-mode override — see
+// `writeTemplateFile`, which reads one explicitly to lay a versioned-mode
+// file down under its real name when `docouture new --mode versioned` is used.
+// It must never be copied under its own literal name by the generic walk
+// below, standalone or not.
+const VERSIONED_MARKER = '.versioned';
+// AGENTS.md needs its own merge logic (see lib/agents-md.ts) rather than a
+// blind overwrite — a repository may already have its own AGENTS.md, or a
+// human may have added notes around docouture' own section since the last
+// `docouture new`/`docouture upgrade`. `new.ts`/`upgrade.ts` read, merge and write
+// it themselves; the generic walk below must skip over it entirely rather
+// than clobbering it the same way it does every other template file.
+const SKIP_FILENAMES = new Set(['AGENTS.md']);
+// npm's publish step unconditionally strips any file matching `.git*`
+// (.gitignore, .gitattributes, .gitmodules, ...) from a package's tarball,
+// regardless of the `files` field or an .npmignore — confirmed here with
+// `npm pack --dry-run` on this very package, which silently drops
+// templates/starter/.gitignore while every sibling file in that directory
+// survives. That means a `.gitignore` template only ever worked when
+// `docouture new` ran from a repo checkout, never from an npm-installed copy —
+// the real-world case. The fix (the same one create-react-app's own
+// template uses): the template source file has no leading dot at all
+// (`gitignore`), and this map renames it back to its real name only at
+// write time, after npm has already packed it safely.
+const DOTFILE_RENAMES = {
+    gitignore: '.gitignore',
+};
+// Extensions copied as raw bytes, no placeholder substitution — logo and
+// favicon assets under `supplemental-ui/` (GH-114). Substituting text tokens
+// into a binary file via `readFile(from, 'utf8')` corrupts it (the bytes get
+// decoded as UTF-8 and re-encoded on write), so these must take a separate,
+// non-text path instead of the generic one below.
+const BINARY_EXTENSIONS = new Set(['.png', '.ico', '.jpg', '.jpeg', '.gif', '.webp']);
+function isBinaryFile(name) {
+    const dot = name.lastIndexOf('.');
+    if (dot === -1)
+        return false;
+    return BINARY_EXTENSIONS.has(name.slice(dot).toLowerCase());
+}
+// Copies every file under `srcDir` into `destDir`, substituting placeholder
+// tokens in each text file. Most template files are plain text (YAML,
+// AsciiDoc, JSON) and go through that substitution; image assets
+// (BINARY_EXTENSIONS) are copied as raw bytes instead — see its own comment.
+// Returns every destination file path written (or, under `dryRun`, that
+// would have been written) — `new.ts` ignores this, `upgrade.ts` uses it
+// both to report progress and to preview a dry run.
+export async function copyTemplate(srcDir, destDir, values, opts = {}) {
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    const written = [];
+    if (!opts.dryRun) {
+        await mkdir(destDir, { recursive: true });
+    }
+    for (const entry of entries) {
+        if (entry.name.includes(VERSIONED_MARKER))
+            continue;
+        if (SKIP_FILENAMES.has(entry.name))
+            continue;
+        const from = join(srcDir, entry.name);
+        const to = join(destDir, DOTFILE_RENAMES[entry.name] ?? entry.name);
+        if (entry.isDirectory()) {
+            written.push(...(await copyTemplate(from, to, values, opts)));
+        }
+        else if (opts.dryRun) {
+            written.push(to);
+        }
+        else if (isBinaryFile(entry.name)) {
+            const content = await readFile(from);
+            await writeFile(to, content);
+            written.push(to);
+        }
+        else {
+            const content = await readFile(from, 'utf8');
+            await writeFile(to, substitute(content, values), 'utf8');
+            written.push(to);
+        }
+    }
+    return written;
+}
+// Overwrites a single already-copied file with a versioning-mode override —
+// used for `antora-playbook.yml` and `docs/.release-version`, whose
+// versioned-mode shape (see reference/versioning-modes.md) differs from the
+// standalone default copyTemplate above lays down (or, for
+// `.release-version`, does not lay down at all). `docs/antora.yml` is NOT
+// overridden this way — it is identical for both modes (see
+// templates/starter/docs/antora.yml's own comment). Same placeholder
+// substitution, just for one file instead of a whole tree.
+export async function writeTemplateFile(srcFile, destFile, values) {
+    const content = await readFile(srcFile, 'utf8');
+    await writeFile(destFile, substitute(content, values), 'utf8');
+}
+// Renders a single template file's placeholder-substituted content without
+// writing it anywhere — used for AGENTS.md (see lib/agents-md.ts), which
+// `new.ts`/`upgrade.ts` need as a string to merge against whatever's already
+// on disk, rather than a file copyTemplate can just write directly.
+export async function renderTemplateFile(srcFile, values) {
+    const content = await readFile(srcFile, 'utf8');
+    return substitute(content, values);
+}
+export async function isEmptyOrMissing(dir) {
+    try {
+        const entries = await readdir(dir);
+        return entries.length === 0;
+    }
+    catch {
+        return true;
+    }
+}
+export async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=copy-template.js.map

package/build/lib/debug-log.js

@@ -0,0 +1,21 @@
+'use strict';
+import { getContext } from './cli-context.js';
+// Node.js CLI convention (see the debug package, and most CLIs that follow
+// it): DEBUG=docouture or DEBUG=* turns this on from the environment, the same
+// as --verbose does from a flag — either is enough. Always written to
+// stderr, never stdout, so it never contaminates a command's actual output
+// (in particular `docouture doctor --json`'s piped-and-parsed JSON).
+function enabled() {
+    if (getContext().verbose)
+        return true;
+    const debug = process.env.DEBUG;
+    if (!debug)
+        return false;
+    return debug.split(',').some((token) => token.trim() === 'docouture' || token.trim() === '*');
+}
+export function debugLog(message) {
+    if (!enabled())
+        return;
+    console.error(`[docouture debug] ${message}`);
+}
+//# sourceMappingURL=debug-log.js.map

package/build/lib/detect-package-manager.js

@@ -0,0 +1,79 @@
+'use strict';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+const PNPM_ACTION_SETUP_STEP = '      - name: Setup pnpm\n' +
+    '        uses: pnpm/action-setup@a3252b78c470c02f7abfb6128aa3c1852013d47c # v4\n' +
+    '\n';
+// Reads the invoking package manager off npm's own user-agent env var — set
+// by npm, pnpm and yarn alike on every script/exec they run, e.g.
+// 'pnpm/9.1.0 npm/? node/v20.11.0 darwin x64'. This is how `docouture new` was
+// actually invoked (`npx @inditextech/docouture-cli` vs `pnpm dlx
+// @inditextech/docouture-cli`) — the best signal available for a brand-new
+// repository with no lockfile of its own yet.
+function fromUserAgent() {
+    const ua = process.env.npm_config_user_agent;
+    if (!ua)
+        return null;
+    if (ua.startsWith('pnpm/'))
+        return 'pnpm';
+    if (ua.startsWith('yarn/'))
+        return 'npm'; // yarn isn't a supported output here — fall through to npm.
+    return 'npm';
+}
+// Best-effort: an existing repository's own package.json#packageManager
+// field (the corepack convention, e.g. "pnpm@9.1.0") wins over anything
+// inferred, since it's an explicit declaration rather than a guess.
+function fromPackageManagerField(targetDir) {
+    try {
+        const raw = readFileSync(join(targetDir, 'package.json'), 'utf8');
+        const pkg = JSON.parse(raw);
+        if (typeof pkg.packageManager === 'string' && pkg.packageManager.startsWith('pnpm@'))
+            return 'pnpm';
+        if (typeof pkg.packageManager === 'string' && pkg.packageManager.startsWith('npm@'))
+            return 'npm';
+    }
+    catch {
+        // No package.json, unreadable, or no such field — fall through.
+    }
+    return null;
+}
+function fromLockfile(targetDir) {
+    if (existsSync(join(targetDir, 'pnpm-lock.yaml')) || existsSync(join(targetDir, 'pnpm-workspace.yaml'))) {
+        return 'pnpm';
+    }
+    return null;
+}
+/**
+ * Which package manager `docouture new`'s printed next-steps (and the
+ * package-manager-aware bits of the scaffolded workflow templates) should
+ * assume for this repository. Checked in order of how much it's worth
+ * trusting: an explicit `packageManager` field first, then a lockfile
+ * already committed at the repo root, then how `docouture new` itself was
+ * invoked, defaulting to npm when none of those say otherwise.
+ */
+export function detectPackageManager(targetDir) {
+    return fromPackageManagerField(targetDir) ?? fromLockfile(targetDir) ?? fromUserAgent() ?? 'npm';
+}
+export function packageManagerPlan(pm) {
+    if (pm === 'pnpm') {
+        return {
+            pm,
+            installCmd: 'pnpm install',
+            devCmd: 'pnpm run dev',
+            ciCmd: 'pnpm install --frozen-lockfile',
+            lockfile: 'pnpm-lock.yaml',
+            cacheName: 'pnpm',
+            setupStepYaml: PNPM_ACTION_SETUP_STEP,
+        };
+    }
+    return {
+        pm,
+        installCmd: 'npm install',
+        devCmd: 'npm run dev',
+        ciCmd: 'npm ci',
+        lockfile: 'package-lock.json',
+        cacheName: 'npm',
+        setupStepYaml: '',
+    };
+}
+//# sourceMappingURL=detect-package-manager.js.map

package/build/lib/dev-server.js

@@ -0,0 +1,337 @@
+'use strict';
+// Development server for a scaffolded Antora site — ported from the
+// monorepo's code/scripts/dev.mjs, trimmed to what a standalone site (no
+// sibling ui-bundle package, ever) actually needs: this package builds and
+// ships the server so a bugfix reaches already-scaffolded sites on their
+// next `npm update @inditextech/docouture-cli`, rather than being frozen at
+// whatever `docouture new` copied at scaffold time.
+//
+// Antora is a batch generator with no incremental mode, so "live reload"
+// here means re-running the whole build on every change and reloading the
+// browser once it lands. A failed rebuild leaves the previous output in
+// place — the browser keeps showing the last version that worked rather
+// than a half-written site.
+import { createServer } from 'node:http';
+import { execFile } from 'node:child_process';
+import { readFile, stat, watch as watchDir } from 'node:fs/promises';
+import { createReadStream, existsSync } from 'node:fs';
+import { extname, isAbsolute, join, normalize, relative, resolve } from 'node:path';
+import { readSiteUrl } from './playbook-yml.js';
+import { ANTORA_LOG_LEVEL_ARGS, filterObservableAntoraLog } from './antora-log.js';
+import { debugLog } from './debug-log.js';
+const RELOAD_PATH = '/__dev/reload';
+const CLIENT_PATH = '/__dev/client.js';
+const DEBOUNCE_MS = 150;
+const BUILD_TIMEOUT_MS = 120_000;
+const CLIENT_SCRIPT = `// Injected by docouture dev. Not part of the built site.
+const es = new EventSource(${JSON.stringify(RELOAD_PATH)})
+es.addEventListener('message', () => location.reload())
+// Chrome (and other browsers) can freeze a navigated-away-from page in the
+// back/forward cache instead of tearing it down — keeping its EventSource
+// open indefinitely. Without this, every navigation leaks one open SSE
+// connection; after enough of them the browser's per-origin connection
+// limit is exhausted and the current page's own requests stop completing.
+// 'pagehide' fires on both a normal unload and a bfcache freeze, so this
+// closes the connection either way.
+window.addEventListener('pagehide', () => es.close())
+`;
+const CONTENT_TYPES = {
+    '.css': 'text/css; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.map': 'application/json; charset=utf-8',
+    '.xml': 'application/xml; charset=utf-8',
+    '.txt': 'text/plain; charset=utf-8',
+};
+const IGNORED = /(?:^|[\\/])(?:\.|.*~$)|\.swp$/;
+function defaultRunBuild(siteRoot, onChildStart) {
+    // On Windows, a locally-installed bin is shimmed as `<name>.cmd`, not the
+    // bare POSIX shell script `execFile` would otherwise try (and fail) to
+    // run directly — see run-script.ts's own comment on the equivalent `npm`
+    // vs `npm.cmd` gotcha.
+    const antoraBinName = process.platform === 'win32' ? 'antora.cmd' : 'antora';
+    const antoraBin = resolve(siteRoot, 'node_modules', '.bin', antoraBinName);
+    return () => new Promise((resolvePromise) => {
+        // No --fetch here: that belongs to the one-off build only — on a
+        // watch loop it would re-fetch the content source on every keystroke.
+        // A timeout guards against a wedged/hung antora child process: with
+        // none, a single stuck build would permanently block every future
+        // rebuild for the rest of the dev session (drain()'s `running` flag
+        // never clears because runBuild() never resolves).
+        debugLog(`spawning: ${antoraBin} antora-playbook.local.yml ${ANTORA_LOG_LEVEL_ARGS.join(' ')}`);
+        const child = execFile(antoraBin, ['antora-playbook.local.yml', ...ANTORA_LOG_LEVEL_ARGS], { cwd: siteRoot, timeout: BUILD_TIMEOUT_MS }, (err, stdout, stderr) => {
+            if (err) {
+                // A failed rebuild gets its raw, unfiltered output — the whole
+                // story, not a filtered excerpt that might cut short exactly
+                // the line that explains the failure.
+                if (stdout)
+                    process.stdout.write(stdout);
+                if (stderr)
+                    process.stderr.write(stderr);
+            }
+            else {
+                // A successful rebuild would otherwise be completely silent —
+                // every docouture-* extension's own observability logs (Kroki's
+                // auto-start/render lifecycle, search-index's summary, ...)
+                // discarded along with Antora's own routine noise. See
+                // antora-log.ts's own header for why `--log-level=info` above
+                // is what makes those lines exist to filter in the first place.
+                const observable = filterObservableAntoraLog(`${stdout}\n${stderr}`);
+                if (observable)
+                    process.stdout.write(observable + '\n');
+            }
+            resolvePromise(!err);
+        });
+        onChildStart?.(child);
+    });
+}
+async function readBasePath(siteRoot) {
+    let source;
+    try {
+        source = await readFile(join(siteRoot, 'antora-playbook.local.yml'), 'utf8');
+    }
+    catch {
+        return '';
+    }
+    const url = readSiteUrl(source);
+    if (!url || url === '/')
+        return '';
+    const path = url.startsWith('/') ? url : URL.parse(url)?.pathname;
+    if (!path || path === '/')
+        return '';
+    return path.replace(/\/+$/, '');
+}
+export async function startDevServer(options) {
+    const { siteRoot } = options;
+    const log = options.log ?? ((msg) => console.log(`dev ${msg}`));
+    const logError = options.logError ?? ((msg) => console.error(`dev ${msg}`));
+    // Only the default build path's child is trackable for a forced kill on
+    // shutdown (below) — a custom options.runBuild (tests; a future
+    // non-Antora build) owns its own process lifecycle, if it has one at all.
+    let activeBuildChild = null;
+    const runBuild = options.runBuild ?? defaultRunBuild(siteRoot, (child) => (activeBuildChild = child));
+    const root = resolve(siteRoot, 'build', 'site');
+    const basePath = await readBasePath(siteRoot);
+    async function resolveTarget(urlPath) {
+        const decoded = decodeURIComponent(urlPath.split('?')[0] ?? '');
+        const candidate = resolve(join(root, normalize(decoded)));
+        // Containment check against `root`, expressed as a relative-path test —
+        // the form static analysis (CodeQL's js/path-injection) recognises as a
+        // real sanitizer, not just `startsWith` on two strings. A `candidate`
+        // outside `root` resolves to a relative path that either escapes
+        // upwards (`..`) or is itself absolute (no common prefix at all).
+        const rel = relative(root, candidate);
+        if (rel.startsWith('..') || isAbsolute(rel))
+            return null;
+        try {
+            const info = await stat(candidate);
+            if (!info.isDirectory())
+                return candidate;
+            const index = join(candidate, 'index.html');
+            await stat(index);
+            return index;
+        }
+        catch {
+            return null;
+        }
+    }
+    const clients = new Set();
+    function notifyReload() {
+        for (const res of clients) {
+            try {
+                res.write('data: reload\n\n');
+            }
+            catch {
+                // Client's socket already gone (e.g. torn down mid-navigation) —
+                // drop it rather than let an unhandled write error crash the
+                // server; the 'error'/'close' listeners below also reap it.
+                clients.delete(res);
+            }
+        }
+    }
+    /**
+     * A path that isn't in the site. Antora only writes `404.html` at the
+     * site root when `site.url` is set (@antora/page-composer
+     * create404Page) — when it does, serve it (rewritten for reload, like
+     * any other HTML response) so the dev server's 404 matches the deployed
+     * one instead of a bare plain-text stand-in.
+     */
+    async function respondNotFound(res) {
+        try {
+            const html = await readFile(join(root, '404.html'), 'utf8');
+            const snippet = `<script src="${CLIENT_PATH}"></script>`;
+            const body = html.includes('</body>') ? html.replace('</body>', `${snippet}</body>`) : html + snippet;
+            res.writeHead(404, { 'content-type': CONTENT_TYPES['.html'], 'cache-control': 'no-store' });
+            res.end(body);
+        }
+        catch {
+            res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+            res.end('404 Not Found');
+        }
+    }
+    const server = createServer((req, res) => {
+        void (async () => {
+            const url = req.url ?? '/';
+            if (url === RELOAD_PATH) {
+                res.writeHead(200, {
+                    'content-type': 'text/event-stream; charset=utf-8',
+                    'cache-control': 'no-cache',
+                    connection: 'keep-alive',
+                });
+                res.write(': connected\n\n');
+                clients.add(res);
+                req.on('close', () => clients.delete(res));
+                // A page navigation can drop the underlying socket before the
+                // 'close' event above fires; without an 'error' listener here
+                // Node's default behaviour for an unhandled stream error is to
+                // throw, taking the whole dev server down mid-navigation.
+                res.on('error', () => clients.delete(res));
+                return;
+            }
+            if (url === CLIENT_PATH) {
+                res.writeHead(200, { 'content-type': 'text/javascript; charset=utf-8', 'cache-control': 'no-store' });
+                res.end(CLIENT_SCRIPT);
+                return;
+            }
+            let sitePath = url;
+            if (basePath) {
+                if (url === '/' || url === basePath) {
+                    res.writeHead(302, { location: `${basePath}/` });
+                    res.end();
+                    return;
+                }
+                if (!url.startsWith(`${basePath}/`)) {
+                    res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+                    res.end(`404 Not Found — this site is served under ${basePath}/`);
+                    return;
+                }
+                sitePath = url.slice(basePath.length);
+            }
+            const target = await resolveTarget(sitePath);
+            if (!target) {
+                await respondNotFound(res);
+                return;
+            }
+            const contentType = CONTENT_TYPES[extname(target)] ?? 'application/octet-stream';
+            if (contentType === CONTENT_TYPES['.html']) {
+                const html = await readFile(target, 'utf8');
+                const snippet = `<script src="${CLIENT_PATH}"></script>`;
+                const body = html.includes('</body>') ? html.replace('</body>', `${snippet}</body>`) : html + snippet;
+                res.writeHead(200, { 'content-type': contentType, 'cache-control': 'no-store' });
+                res.end(body);
+                return;
+            }
+            res.writeHead(200, { 'content-type': contentType, 'cache-control': 'no-store' });
+            createReadStream(target).pipe(res);
+        })();
+    });
+    let running = false;
+    let queued = false;
+    let timer = null;
+    function schedule() {
+        queued = true;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => void drain(), DEBOUNCE_MS);
+    }
+    async function drain() {
+        timer = null;
+        if (running || !queued)
+            return;
+        running = true;
+        try {
+            while (queued) {
+                queued = false;
+                const started = Date.now();
+                log('content changed, rebuilding site');
+                const ok = await runBuild();
+                if (ok) {
+                    log(`rebuilt in ${((Date.now() - started) / 1000).toFixed(1)}s`);
+                    notifyReload();
+                }
+                else {
+                    logError('rebuild failed, serving the previous build');
+                }
+            }
+        }
+        catch (err) {
+            // A build that throws instead of resolving false must not leave
+            // `running` stuck true forever — that would silently disable every
+            // future rebuild for the rest of the dev session.
+            logError(`rebuild crashed, serving the previous build: ${err.message}`);
+        }
+        finally {
+            running = false;
+        }
+    }
+    const watchAbort = new AbortController();
+    async function watchPath(path, watchOptions = {}) {
+        try {
+            for await (const event of watchDir(path, {
+                recursive: watchOptions.recursive ?? true,
+                signal: watchAbort.signal,
+            })) {
+                if (event.filename && IGNORED.test(event.filename))
+                    continue;
+                schedule();
+            }
+        }
+        catch (err) {
+            if (err.name !== 'AbortError') {
+                logError(`stopped watching ${path}: ${err.message}`);
+            }
+        }
+    }
+    if (!existsSync(root)) {
+        log('no build output yet, building the site');
+        if (!(await runBuild())) {
+            throw new Error('initial build failed');
+        }
+    }
+    await new Promise((resolvePromise, reject) => {
+        server.once('error', reject);
+        server.listen(options.port ?? 5000, () => {
+            server.off('error', reject);
+            resolvePromise();
+        });
+    });
+    const address = server.address();
+    const port = typeof address === 'object' && address ? address.port : (options.port ?? 5000);
+    log(`serving ${root}`);
+    log(`  http://localhost:${port}${basePath}/`);
+    const watchers = [
+        watchPath(join(siteRoot, 'docs')),
+        watchPath(join(siteRoot, 'antora-playbook.local.yml'), { recursive: false }),
+    ];
+    void Promise.all(watchers);
+    return {
+        port,
+        basePath,
+        url: `http://localhost:${port}${basePath}/`,
+        async close() {
+            watchAbort.abort();
+            if (timer)
+                clearTimeout(timer);
+            // A rebuild that's still in flight when SIGINT/SIGTERM arrives would
+            // otherwise be left running as an orphan after the dev server itself
+            // has already torn down — kill it too, best-effort (it may already
+            // have exited on its own by the time close() runs).
+            if (activeBuildChild && activeBuildChild.exitCode === null && !activeBuildChild.killed) {
+                activeBuildChild.kill('SIGTERM');
+            }
+            for (const res of clients)
+                res.end();
+            await new Promise((resolvePromise) => server.close(() => resolvePromise()));
+        },
+    };
+}
+//# sourceMappingURL=dev-server.js.map