create-ortha-app 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ortha CMS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# create-ortha-app
+
+Part of [Ortha CMS](https://github.com/ortha-source/ortha-cms).
+
+```sh
+npm install create-ortha-app
+```

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:readline/promises");
+const features_1 = require("./lib/features");
+const template_1 = require("./lib/template");
+const ui = tslib_1.__importStar(require("./lib/ui"));
+const validate_1 = require("./lib/validate");
+const USAGE = `create-ortha-app — scaffold an Ortha CMS app
+
+Usage: npx create-ortha-app <directory> [options]
+
+Options:
+  --yes            Accept every default, asking nothing
+  --media <id>     Storage adapter (default: media-local)
+  --copilot <ids>  Comma-separated copilot providers, or "none"
+  --sso <ids>      Comma-separated identity providers (sso-oidc), or "none"
+  --protocols <ids> Comma-separated protocols beyond REST (graphql, mcp), or "none"
+  --no-install     Skip installing dependencies
+  --no-git         Skip initialising a git repository
+  -h, --help       Show this message
+`;
+/** Whether a bare `--flag` is present. */
+function flag(argv, name) {
+    return argv.includes(`--${name}`);
+}
+/** Reads `--name=value` or `--name value` from argv. */
+function option(argv, name) {
+    const inline = argv.find((arg) => arg.startsWith(`--${name}=`));
+    if (inline)
+        return inline.slice(`--${name}=`.length);
+    const index = argv.indexOf(`--${name}`);
+    const next = index === -1 ? undefined : argv[index + 1];
+    return next && !next.startsWith('-') ? next : undefined;
+}
+/** Splits a comma-separated flag value; `none` means an empty selection. */
+function idList(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (raw.trim() === 'none')
+        return [];
+    return raw
+        .split(',')
+        .map((id) => id.trim())
+        .filter(Boolean);
+}
+/**
+ * This package's own version, which every `@orthacms/*` dependency in the
+ * generated app is pinned to.
+ *
+ * The scaffolder is released in lockstep with the packages it scaffolds, so its
+ * version *is* the matching set — which is the whole mechanism keeping a
+ * generated app internally consistent. Reading it from the manifest rather than
+ * resolving `latest` from the registry also means `npx create-ortha-app@0.3.0`
+ * generates a 0.3.0 app, not whatever shipped since.
+ */
+function ownVersion() {
+    const manifest = (0, node_path_1.join)(__dirname, '../package.json');
+    return JSON.parse((0, node_fs_1.readFileSync)(manifest, 'utf8'))
+        .version;
+}
+/** Runs a command in `cwd`, returning whether it succeeded. */
+function runCommand(command, args, cwd) {
+    return ((0, node_child_process_1.spawnSync)(command, args, {
+        cwd,
+        stdio: 'inherit',
+        shell: process.platform === 'win32'
+    }).status === 0);
+}
+/** Turns a feature into a picker row. */
+function toChoice(feature) {
+    return {
+        value: feature.id,
+        label: feature.label,
+        hint: feature.hint,
+        selected: feature.enabledByDefault,
+        disabled: !feature.available,
+        locked: feature.locked
+    };
+}
+/**
+ * The ids a feature group falls back to when nothing is picked.
+ *
+ * A locked feature is in every answer, including `--protocols none`: REST is
+ * not something the flag can switch off.
+ */
+function defaultsOf(features) {
+    return features
+        .filter((feature) => (feature.enabledByDefault || feature.locked) &&
+        feature.available)
+        .map((feature) => feature.id);
+}
+/** The ids that are on regardless of what was asked or passed. */
+function lockedOf(features) {
+    return features
+        .filter((feature) => feature.locked && feature.available)
+        .map((feature) => feature.id);
+}
+/** Asks a free-text question, re-asking until it validates. */
+async function askText(label, fallback, validate) {
+    const rl = (0, promises_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        for (;;) {
+            const raw = await rl.question(`${ui.cyan('◆')} ${ui.bold(label)} ${ui.dim(`(${fallback})`)} `);
+            const answer = raw.trim() || fallback;
+            const problem = validate?.(answer);
+            if (!problem)
+                return answer;
+            ui.error(problem);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Resolves the answers, asking only when there is a terminal to ask in.
+ *
+ * Non-interactive is not an error case to warn about — it is CI, a piped
+ * install, and `--yes`. A scaffolder that blocks on a prompt nobody can answer
+ * hangs a pipeline until it times out, which is a far worse failure than
+ * defaulting, so the flags and the defaults cover every question.
+ */
+async function resolveAnswers(argv, defaultName) {
+    const asked = !flag(argv, 'yes') && ui.interactive();
+    const defaultDatabaseUrl = `postgresql://ortha:ortha@localhost:5432/${defaultName.replace(/[^a-z0-9_]/gi, '_')}`;
+    const media = idList(option(argv, 'media')) ?? defaultsOf(features_1.MEDIA_PROVIDERS);
+    const copilot = idList(option(argv, 'copilot')) ?? defaultsOf(features_1.COPILOT_PROVIDERS);
+    const sso = idList(option(argv, 'sso')) ?? defaultsOf(features_1.SSO_PROVIDERS);
+    const protocols = [
+        ...lockedOf(features_1.PROTOCOLS),
+        ...(idList(option(argv, 'protocols')) ?? defaultsOf(features_1.PROTOCOLS))
+    ];
+    if (!asked) {
+        return {
+            appName: defaultName,
+            databaseUrl: defaultDatabaseUrl,
+            adminEmail: 'admin@example.com',
+            selection: {
+                enabled: new Set([...media, ...copilot, ...sso, ...protocols])
+            }
+        };
+    }
+    ui.section('Project');
+    const appName = await askText('App name', defaultName, validate_1.validateAppName);
+    const databaseUrl = await askText('Database URL', defaultDatabaseUrl, validate_1.validateDatabaseUrl);
+    const adminEmail = await askText('Admin email', 'admin@example.com');
+    ui.section('Features');
+    ui.note('Everything else is installed for you. These are the choices.');
+    console.log('');
+    // Only ask when there is more than one answer available. S3 is not
+    // published, so today this is a question with a single possible reply, and
+    // asking it would be noise pretending to be a choice.
+    const selectable = features_1.MEDIA_PROVIDERS.filter((provider) => provider.available);
+    const chosenMedia = selectable.length > 1
+        ? [
+            (await ui.select('Where should uploads be stored?', features_1.MEDIA_PROVIDERS.map(toChoice))) ?? media[0]
+        ]
+        : media;
+    const chosenCopilot = (await ui.multiselect('AI copilot — which model backends?', features_1.COPILOT_PROVIDERS.map(toChoice))) ?? copilot;
+    const chosenSso = (await ui.multiselect('Single sign-on — which identity providers?', features_1.SSO_PROVIDERS.map(toChoice))) ?? sso;
+    const chosenProtocols = (await ui.multiselect('Which protocols should the content API speak?', features_1.PROTOCOLS.map(toChoice))) ?? protocols;
+    return {
+        appName,
+        databaseUrl,
+        adminEmail,
+        selection: {
+            enabled: new Set([
+                ...chosenMedia.filter(Boolean),
+                ...chosenCopilot,
+                ...chosenSso,
+                ...chosenProtocols
+            ])
+        }
+    };
+}
+/** Human-readable summary of what was chosen. */
+function describeSelection(selection) {
+    const labelsFor = (features) => {
+        const chosen = features
+            .filter((feature) => selection.enabled.has(feature.id))
+            .map((feature) => feature.label);
+        return chosen.length > 0 ? chosen.join(', ') : ui.dim('none');
+    };
+    const providers = features_1.COPILOT_PROVIDERS.filter((provider) => selection.enabled.has(provider.id));
+    return [
+        ['Storage', labelsFor(features_1.MEDIA_PROVIDERS)],
+        ['Protocols', labelsFor(features_1.PROTOCOLS)],
+        [
+            'Copilot',
+            providers.length > 0
+                ? `${providers.map((p) => p.label).join(', ')} + offline fake`
+                : 'offline fake only'
+        ],
+        ['Sign-in', labelsFor(features_1.SSO_PROVIDERS)],
+        ['Ortha packages', String((0, features_1.resolvePackages)(selection).length + 1)]
+    ];
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (flag(argv, 'help') || argv.includes('-h')) {
+        console.log(USAGE);
+        return;
+    }
+    const positional = argv.filter((arg) => !arg.startsWith('-'));
+    const target = (0, node_path_1.resolve)(positional[0] ?? '.');
+    ui.banner('Ortha CMS', `Creating an app in ${target}`);
+    if ((0, template_1.isNonEmptyDirectory)(target)) {
+        throw new Error(`${target} already exists and is not empty. Pick a new directory, ` +
+            `or empty that one first.`);
+    }
+    const answers = await resolveAnswers(argv, (0, node_path_1.basename)(target));
+    // Generated rather than prompted: a password typed at a prompt is echoed to
+    // the terminal and lands in shell history. This one is written only to the
+    // git-ignored .env, and printed once below.
+    const adminPassword = (0, node_crypto_1.randomBytes)(12).toString('base64url');
+    ui.summary('Your app', [
+        ['Name', answers.appName],
+        ['Database', (0, validate_1.databaseNameFrom)(answers.databaseUrl)],
+        ...describeSelection(answers.selection)
+    ]);
+    (0, node_fs_1.mkdirSync)(target, { recursive: true });
+    (0, template_1.renderTemplate)((0, node_path_1.join)(__dirname, '../templates/default'), target, {
+        appName: answers.appName,
+        appTitle: answers.appName,
+        databaseUrl: answers.databaseUrl,
+        databaseName: (0, validate_1.databaseNameFrom)(answers.databaseUrl),
+        adminEmail: answers.adminEmail,
+        adminPassword,
+        orthaVersion: ownVersion(),
+        selection: answers.selection
+    });
+    console.log('');
+    ui.success('Files written');
+    if (!flag(argv, 'no-git') && !(0, node_fs_1.existsSync)((0, node_path_1.join)(target, '.git'))) {
+        if (runCommand('git', ['init', '--quiet'], target)) {
+            ui.success('Git repository initialised');
+        }
+    }
+    let installed = true;
+    if (!flag(argv, 'no-install')) {
+        console.log('');
+        ui.note('Installing dependencies…');
+        installed = runCommand('npm', ['install', '--no-audit', '--no-fund'], target);
+        if (installed)
+            ui.success('Dependencies installed');
+    }
+    if (!installed) {
+        ui.error('Dependency installation failed — fix the error above, then run ' +
+            '`npm install` in the new directory.');
+        process.exitCode = 1;
+    }
+    ui.summary('Your admin account', [
+        ['Email', answers.adminEmail],
+        ['Password', ui.bold(adminPassword)],
+        ['', ui.dim('Also written to .env')]
+    ]);
+    ui.nextSteps([
+        `cd ${(0, node_path_1.basename)(target)}`,
+        ...(flag(argv, 'no-install') ? ['npm install'] : []),
+        'docker compose up -d',
+        'npm run migrate',
+        `npm run dev        ${ui.dim('→ http://localhost:4200')}`
+    ]);
+}
+main().catch((error) => {
+    ui.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Public API of `create-ortha-app`.
+ *
+ * The package is used through `npx`; these exports exist so the rendering,
+ * feature resolution and validation are testable without spawning the binary.
+ */
+export { renderTemplate, renderManifest, render, isNonEmptyDirectory, type TemplateValues } from './lib/template';
+export { applyConditionals } from './lib/conditionals';
+export { CORE_PACKAGES, CORE_DEV_PACKAGES, TRANSITIVE_PACKAGES, MEDIA_PROVIDERS, COPILOT_PROVIDERS, SSO_PROVIDERS, PROTOCOLS, ALL_FEATURES, resolvePackages, resolveDevPackages, resolveFlags, type Feature, type FeatureSelection } from './lib/features';
+export { validateAppName, validateDatabaseUrl, databaseNameFrom } from './lib/validate';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACH,cAAc,EACd,cAAc,EACd,MAAM,EACN,mBAAmB,EACnB,KAAK,cAAc,EACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EACH,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,SAAS,EACT,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,YAAY,EACZ,KAAK,OAAO,EACZ,KAAK,gBAAgB,EACxB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACH,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACnB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.databaseNameFrom = exports.validateDatabaseUrl = exports.validateAppName = exports.resolveFlags = exports.resolveDevPackages = exports.resolvePackages = exports.ALL_FEATURES = exports.PROTOCOLS = exports.SSO_PROVIDERS = exports.COPILOT_PROVIDERS = exports.MEDIA_PROVIDERS = exports.TRANSITIVE_PACKAGES = exports.CORE_DEV_PACKAGES = exports.CORE_PACKAGES = exports.applyConditionals = exports.isNonEmptyDirectory = exports.render = exports.renderManifest = exports.renderTemplate = void 0;
+/**
+ * Public API of `create-ortha-app`.
+ *
+ * The package is used through `npx`; these exports exist so the rendering,
+ * feature resolution and validation are testable without spawning the binary.
+ */
+var template_1 = require("./lib/template");
+Object.defineProperty(exports, "renderTemplate", { enumerable: true, get: function () { return template_1.renderTemplate; } });
+Object.defineProperty(exports, "renderManifest", { enumerable: true, get: function () { return template_1.renderManifest; } });
+Object.defineProperty(exports, "render", { enumerable: true, get: function () { return template_1.render; } });
+Object.defineProperty(exports, "isNonEmptyDirectory", { enumerable: true, get: function () { return template_1.isNonEmptyDirectory; } });
+var conditionals_1 = require("./lib/conditionals");
+Object.defineProperty(exports, "applyConditionals", { enumerable: true, get: function () { return conditionals_1.applyConditionals; } });
+var features_1 = require("./lib/features");
+Object.defineProperty(exports, "CORE_PACKAGES", { enumerable: true, get: function () { return features_1.CORE_PACKAGES; } });
+Object.defineProperty(exports, "CORE_DEV_PACKAGES", { enumerable: true, get: function () { return features_1.CORE_DEV_PACKAGES; } });
+Object.defineProperty(exports, "TRANSITIVE_PACKAGES", { enumerable: true, get: function () { return features_1.TRANSITIVE_PACKAGES; } });
+Object.defineProperty(exports, "MEDIA_PROVIDERS", { enumerable: true, get: function () { return features_1.MEDIA_PROVIDERS; } });
+Object.defineProperty(exports, "COPILOT_PROVIDERS", { enumerable: true, get: function () { return features_1.COPILOT_PROVIDERS; } });
+Object.defineProperty(exports, "SSO_PROVIDERS", { enumerable: true, get: function () { return features_1.SSO_PROVIDERS; } });
+Object.defineProperty(exports, "PROTOCOLS", { enumerable: true, get: function () { return features_1.PROTOCOLS; } });
+Object.defineProperty(exports, "ALL_FEATURES", { enumerable: true, get: function () { return features_1.ALL_FEATURES; } });
+Object.defineProperty(exports, "resolvePackages", { enumerable: true, get: function () { return features_1.resolvePackages; } });
+Object.defineProperty(exports, "resolveDevPackages", { enumerable: true, get: function () { return features_1.resolveDevPackages; } });
+Object.defineProperty(exports, "resolveFlags", { enumerable: true, get: function () { return features_1.resolveFlags; } });
+var validate_1 = require("./lib/validate");
+Object.defineProperty(exports, "validateAppName", { enumerable: true, get: function () { return validate_1.validateAppName; } });
+Object.defineProperty(exports, "validateDatabaseUrl", { enumerable: true, get: function () { return validate_1.validateDatabaseUrl; } });
+Object.defineProperty(exports, "databaseNameFrom", { enumerable: true, get: function () { return validate_1.databaseNameFrom; } });

package/dist/lib/conditionals.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `ortha:if` blocks — how one template serves every feature combination.
+ *
+ * A marker is any line containing the directive, whatever comment syntax wraps
+ * it, so the same three forms work in TypeScript, YAML, `.env` and Markdown:
+ *
+ *     // ortha:if copilot
+ *     import { CopilotPlugin } from '@orthacms/copilot-server';
+ *     // ortha:end
+ *
+ *     # ortha:ifnot graphql
+ *     # (REST only — no GraphQL endpoint is mounted.)
+ *     # ortha:end
+ *
+ * The marker lines are always removed; the body survives only when the
+ * condition holds. Blocks may nest, and an inner block is only reached when
+ * the outer one is kept.
+ *
+ * Deliberately line-based rather than an expression language. The templates are
+ * read far more often than they are written — someone opening
+ * `plugins.ts` should see the real file with a few comments in it, not a
+ * templating dialect — and every condition this needs is "is this feature on".
+ *
+ * **Not used for `package.json`.** Dropping lines from JSON produces a trailing
+ * comma and an app that will not install, blaming the template rather than the
+ * feature that was switched off; dependencies are assembled in `features.ts`
+ * instead.
+ */
+/**
+ * Applies every `ortha:if` block in `contents` against the enabled `flags`.
+ *
+ * @throws when a block is left open, which would otherwise silently swallow the
+ * rest of the file — a missing `ortha:end` in `plugins.ts` deletes every plugin
+ * below it, and the app boots with no API rather than failing to render.
+ */
+export declare function applyConditionals(contents: string, flags: ReadonlySet<string>, file?: string): string;
+//# sourceMappingURL=conditionals.d.ts.map

package/dist/lib/conditionals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionals.d.ts","sourceRoot":"","sources":["../../src/lib/conditionals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAmCH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,IAAI,SAAa,GAClB,MAAM,CA0CR"}

package/dist/lib/conditionals.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * `ortha:if` blocks — how one template serves every feature combination.
+ *
+ * A marker is any line containing the directive, whatever comment syntax wraps
+ * it, so the same three forms work in TypeScript, YAML, `.env` and Markdown:
+ *
+ *     // ortha:if copilot
+ *     import { CopilotPlugin } from '@orthacms/copilot-server';
+ *     // ortha:end
+ *
+ *     # ortha:ifnot graphql
+ *     # (REST only — no GraphQL endpoint is mounted.)
+ *     # ortha:end
+ *
+ * The marker lines are always removed; the body survives only when the
+ * condition holds. Blocks may nest, and an inner block is only reached when
+ * the outer one is kept.
+ *
+ * Deliberately line-based rather than an expression language. The templates are
+ * read far more often than they are written — someone opening
+ * `plugins.ts` should see the real file with a few comments in it, not a
+ * templating dialect — and every condition this needs is "is this feature on".
+ *
+ * **Not used for `package.json`.** Dropping lines from JSON produces a trailing
+ * comma and an app that will not install, blaming the template rather than the
+ * feature that was switched off; dependencies are assembled in `features.ts`
+ * instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyConditionals = applyConditionals;
+/**
+ * A trailing comment closer, so a block-comment directive works too — `*\/`
+ * for CSS and C-style block comments, `-->` for HTML.
+ */
+const CLOSER = String.raw `(?:\s*(?:\*\/|-->))?`;
+const IF = new RegExp(String.raw `(^|\s)ortha:if\s+([a-z0-9-]+)${CLOSER}\s*$`);
+const IFNOT = new RegExp(String.raw `(^|\s)ortha:ifnot\s+([a-z0-9-]+)${CLOSER}\s*$`);
+const END = new RegExp(String.raw `(^|\s)ortha:end${CLOSER}\s*$`);
+/** Reads the directive on `line`, or `undefined` for an ordinary line. */
+function directiveOf(line) {
+    const trimmed = line.trimEnd();
+    const ifMatch = IF.exec(trimmed);
+    if (ifMatch)
+        return { kind: 'if', flag: ifMatch[2] };
+    const ifNotMatch = IFNOT.exec(trimmed);
+    if (ifNotMatch)
+        return { kind: 'ifnot', flag: ifNotMatch[2] };
+    if (END.test(trimmed))
+        return { kind: 'end' };
+    return undefined;
+}
+/**
+ * Applies every `ortha:if` block in `contents` against the enabled `flags`.
+ *
+ * @throws when a block is left open, which would otherwise silently swallow the
+ * rest of the file — a missing `ortha:end` in `plugins.ts` deletes every plugin
+ * below it, and the app boots with no API rather than failing to render.
+ */
+function applyConditionals(contents, flags, file = 'template') {
+    const lines = contents.split('\n');
+    const kept = [];
+    // One entry per open block: whether its body is being written out. A nested
+    // block inside a dropped one stays dropped whatever its own condition says.
+    const stack = [];
+    const writing = () => stack.every(Boolean);
+    for (const line of lines) {
+        const directive = directiveOf(line);
+        if (!directive) {
+            if (writing())
+                kept.push(line);
+            continue;
+        }
+        if (directive.kind === 'end') {
+            if (stack.length === 0) {
+                throw new Error(`${file}: an \`ortha:end\` with no matching \`ortha:if\`.`);
+            }
+            stack.pop();
+            continue;
+        }
+        const holds = directive.kind === 'if'
+            ? flags.has(directive.flag)
+            : !flags.has(directive.flag);
+        stack.push(holds);
+    }
+    if (stack.length > 0) {
+        throw new Error(`${file}: ${stack.length} unclosed \`ortha:if\` block(s) — every ` +
+            `one needs an \`ortha:end\`, or the rest of the file is dropped.`);
+    }
+    return collapseBlankRuns(kept).join('\n');
+}
+/**
+ * Collapses runs of three or more blank lines into one.
+ *
+ * Removing a block almost always leaves the blank line that separated it behind
+ * next to the one after it. Without this every generated file carries a scar
+ * wherever a feature was switched off, which reads as sloppiness in the very
+ * first file anyone opens.
+ */
+function collapseBlankRuns(lines) {
+    const out = [];
+    let blanks = 0;
+    for (const line of lines) {
+        if (line.trim() === '') {
+            blanks += 1;
+            if (blanks > 1)
+                continue;
+        }
+        else {
+            blanks = 0;
+        }
+        out.push(line);
+    }
+    return out;
+}