@lenne.tech/cli 1.11.1 → 1.13.0

package/build/commands/claude/shortcuts.js

@@ -30,6 +30,11 @@ const CLAUDE_SHORTCUTS = [
         command: 'claude --dangerously-skip-permissions --resume',
         description: 'Select and resume previous session',
     },
+    {
+        alias: 'cf',
+        command: 'LT_PLUGIN_HOOKS_SKIP=1 claude --dangerously-skip-permissions',
+        description: 'Start Claude Code in fast mode (skip lenne.tech plugin detect hooks)',
+    },
 ];
 /**
  * Install Claude Code shell shortcuts

package/build/commands/config/validate.js

@@ -114,6 +114,22 @@ const KNOWN_KEYS = {
                 path: 'string',
             },
         },
+        tools: {
+            crawl: {
+                concurrency: 'number',
+                depth: 'number|all',
+                includeImages: 'boolean',
+                includeSitemap: 'boolean',
+                maxPages: 'number',
+                noConfirm: 'boolean',
+                out: 'string',
+                prune: 'boolean',
+                renderJs: 'boolean',
+                selector: 'string',
+                timeout: 'number',
+            },
+            noConfirm: 'boolean',
+        },
         typescript: {
             create: { author: 'string', noConfirm: 'boolean', updatePackages: 'boolean' },
         },
@@ -165,8 +181,26 @@ function validateConfig(config, knownKeys, path = '') {
         }
         // Validate type
         if (typeof expectedType === 'string') {
-            // Simple type check
-            if (expectedType === 'string' && typeof value !== 'string') {
+            // Simple type check. `'a|b'` means union (e.g. "number|all").
+            if (expectedType.includes('|')) {
+                const tokens = expectedType.split('|').map((t) => t.trim());
+                const ok = tokens.some((token) => {
+                    if (token === 'string')
+                        return typeof value === 'string';
+                    if (token === 'number')
+                        return typeof value === 'number';
+                    if (token === 'boolean')
+                        return typeof value === 'boolean';
+                    if (token === 'array')
+                        return Array.isArray(value);
+                    // Everything else is treated as a string literal enum member.
+                    return value === token;
+                });
+                if (!ok) {
+                    result.errors.push(`${currentPath}: expected ${tokens.join(' | ')}, got ${typeof value}`);
+                }
+            }
+            else if (expectedType === 'string' && typeof value !== 'string') {
                 result.errors.push(`${currentPath}: expected string, got ${typeof value}`);
             }
             else if (expectedType === 'boolean' && typeof value !== 'boolean') {

package/build/commands/fullstack/init.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const hoist_workspace_pnpm_config_1 = require("../../lib/hoist-workspace-pnpm-config");
 /**
  * Create a new fullstack workspace
  */
@@ -456,6 +457,14 @@ const NewCommand = {
             else {
                 serverSpinner.warn('Nest Server Starter not integrated');
             }
+            // Hoist workspace-scoped pnpm config out of sub-projects. pnpm only
+            // honors `pnpm.overrides`, `pnpm.onlyBuiltDependencies`, and
+            // `pnpm.ignoredOptionalDependencies` at the workspace root; leaving
+            // them in projects/api/package.json or projects/app/package.json
+            // causes `WARN The field … was found in … This will not take
+            // effect. You should configure … at the root of the workspace
+            // instead.` and silently disables CVE overrides.
+            (0, hoist_workspace_pnpm_config_1.hoistWorkspacePnpmConfig)({ filesystem, projectDir, subProjects: ['projects/api', 'projects/app'] });
             // Install all packages
             const installSpinner = spin('Install all packages');
             try {
@@ -467,6 +476,18 @@ const NewCommand = {
                 installSpinner.fail(`Failed to install packages: ${err.message}`);
                 return;
             }
+            // Post-install format pass. processApiMode (run earlier in
+            // setupServerForFullstack) and convertAppCloneToVendored rewrite
+            // source files, leaving whitespace artifacts that oxfmt flags in
+            // `pnpm run format:check` (multi-line arrays/imports after region
+            // stripping, import-path rewrites that now fit single-line). The
+            // formatter is only available after install, so we normalize here.
+            if (apiMode && filesystem.isDirectory(`${projectDir}/projects/api`)) {
+                yield toolbox.apiMode.formatProject(`${projectDir}/projects/api`);
+            }
+            if (isNuxt && filesystem.isDirectory(`${projectDir}/projects/app`)) {
+                yield toolbox.apiMode.formatProject(`${projectDir}/projects/app`);
+            }
             // Create initial commit after everything is set up
             try {
                 yield system.run(`cd ${projectDir} && git add . && git commit -m "Initial commit"`);

package/build/commands/fullstack/update.js

@@ -126,10 +126,7 @@ const NewCommand = {
         info(colors.dim('─'.repeat(60)));
         info('');
         // Detect frontend project
-        const appCandidates = [
-            (0, path_1.join)(cwd, 'projects', 'app'),
-            (0, path_1.join)(cwd, 'packages', 'app'),
-        ].filter((p) => Boolean(p));
+        const appCandidates = [(0, path_1.join)(cwd, 'projects', 'app'), (0, path_1.join)(cwd, 'packages', 'app')].filter((p) => Boolean(p));
         let appDir;
         for (const candidate of appCandidates) {
             if (filesystem.exists((0, path_1.join)(candidate, 'nuxt.config.ts')) || filesystem.exists((0, path_1.join)(candidate, 'package.json'))) {

package/build/commands/git/reset.js

@@ -45,8 +45,8 @@ const NewCommand = {
             error('No current branch!');
             return;
         }
-        // Check remote
-        const remoteBranch = yield system.run(`git ls-remote --heads origin ${branch}`);
+        // Check remote (use short SSH timeout so ls-remote doesn't hang in offline environments)
+        const remoteBranch = yield system.run(`GIT_TERMINAL_PROMPT=0 GIT_SSH_COMMAND="ssh -o ConnectTimeout=5 -o BatchMode=yes" git ls-remote --heads origin ${branch} 2>/dev/null || true`);
         if (!remoteBranch) {
             error(`No remote branch ${branch} found!`);
             return;

package/build/commands/git/update.js

@@ -47,8 +47,8 @@ const NewCommand = {
             info('');
             info(`Current branch: ${branch}`);
             info('');
-            // Fetch to see incoming changes
-            yield run('git fetch');
+            // Fetch to see incoming changes (use short SSH timeout so it doesn't hang offline)
+            yield run('GIT_TERMINAL_PROMPT=0 GIT_SSH_COMMAND="ssh -o ConnectTimeout=5 -o BatchMode=yes" git fetch 2>/dev/null || true');
             // Check for incoming commits
             const incomingCommits = yield run(`git log ${branch}..origin/${branch} --oneline 2>/dev/null || echo ""`);
             const commits = (incomingCommits === null || incomingCommits === void 0 ? void 0 : incomingCommits.trim().split('\n').filter((c) => c)) || [];
@@ -78,7 +78,7 @@ const NewCommand = {
         const timer = startTimer();
         // Update
         const updateSpin = spin(`Update branch ${branch}`);
-        yield run('git fetch && git pull --rebase');
+        yield run('GIT_TERMINAL_PROMPT=0 GIT_SSH_COMMAND="ssh -o ConnectTimeout=5 -o BatchMode=yes" git fetch 2>/dev/null || true && GIT_TERMINAL_PROMPT=0 GIT_SSH_COMMAND="ssh -o ConnectTimeout=5 -o BatchMode=yes" git pull --rebase');
         updateSpin.succeed();
         // Install packages (unless skipped) with correctly detected package manager (supports monorepo lockfiles)
         if (!skipInstall) {

package/build/commands/server/add-property.js

@@ -434,9 +434,7 @@ const NewCommand = {
                 // path to src/core whose depth depends on the model file location.
                 // We search for BOTH forms so this works regardless of how the file
                 // was originally generated.
-                const vendoredSpec = (0, framework_detection_1.isVendoredProject)(path)
-                    ? (0, framework_detection_1.getFrameworkImportSpecifier)(path, modelPath)
-                    : null;
+                const vendoredSpec = (0, framework_detection_1.isVendoredProject)(path) ? (0, framework_detection_1.getFrameworkImportSpecifier)(path, modelPath) : null;
                 let existingImports = moduleFile.getImportDeclaration('@lenne.tech/nest-server');
                 if (!existingImports && vendoredSpec) {
                     existingImports = moduleFile.getImportDeclaration(vendoredSpec);

package/build/commands/server/module.js

@@ -410,7 +410,7 @@ const NewCommand = {
                     // plus the `from '@nestjs/common'` clause. The replacement wedges
                     // `, forwardRef` in between.
                     yield patching.patch(serverModule, {
-                        insert: "$1, forwardRef$2",
+                        insert: '$1, forwardRef$2',
                         replace: /(import\s*\{\s*[^}]*?)(\s*\}\s*from\s+['"]@nestjs\/common['"])/,
                     });
                 }

package/build/commands/tools/crawl.js

@@ -0,0 +1,307 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const crawler_1 = require("../../lib/crawler");
+/**
+ * Crawl a website (optionally following same-origin links up to a
+ * configurable depth) and store the content as Markdown files for use
+ * as a Claude Code knowledge base. Inspired by ../../../../chrome-md:
+ * shares the defuddle + Turndown extraction pipeline but runs headless
+ * from Node and follows links / sitemaps automatically.
+ */
+const NewCommand = {
+    alias: ['cr'],
+    description: 'Crawl site to Markdown',
+    hidden: false,
+    name: 'crawl',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const { config, filesystem, helper, parameters, print: { error, info, spin, success, warning }, prompt: { confirm }, tools, } = toolbox;
+        if (tools.helpJson({
+            aliases: ['cr'],
+            description: 'Crawl a website into Markdown files (for Claude Code knowledge bases)',
+            name: 'crawl',
+            options: [
+                {
+                    description: 'Start URL (absolute http/https URL)',
+                    flag: '--url',
+                    required: true,
+                    type: 'string',
+                },
+                {
+                    default: '.',
+                    description: 'Output directory (created if missing)',
+                    flag: '--out',
+                    type: 'string',
+                },
+                {
+                    default: 0,
+                    description: 'Link depth. 0 = only start page; 1 = + direct links; N = up to N hops; "all" (or -1) = follow every same-origin link until --max-pages is reached',
+                    flag: '--depth',
+                    type: 'number|all',
+                },
+                {
+                    default: true,
+                    description: 'Download images and inline them with local paths',
+                    flag: '--images',
+                    type: 'boolean',
+                },
+                {
+                    default: true,
+                    description: 'Also seed queue from <origin>/sitemap.xml',
+                    flag: '--sitemap',
+                    type: 'boolean',
+                },
+                {
+                    default: 4,
+                    description: 'Parallel HTTP requests',
+                    flag: '--concurrency',
+                    type: 'number',
+                },
+                {
+                    default: 200,
+                    description: 'Maximum number of pages to crawl (safety cap)',
+                    flag: '--max-pages',
+                    type: 'number',
+                },
+                {
+                    description: 'CSS selector for the main content container',
+                    flag: '--selector',
+                    type: 'string',
+                },
+                {
+                    default: 20000,
+                    description: 'HTTP request timeout in ms',
+                    flag: '--timeout',
+                    type: 'number',
+                },
+                {
+                    default: false,
+                    description: 'Shortcut for --depth all (follows every same-origin link until --max-pages)',
+                    flag: '--all',
+                    type: 'boolean',
+                },
+                {
+                    default: true,
+                    description: "Render pages through a headless browser before extracting (for SPAs like Vue/Nuxt/React/Angular). Uses playwright-core with system Chrome / Edge, falling back to Playwright's bundled chromium. Disable with --no-render for plain HTTP fetches.",
+                    flag: '--render',
+                    type: 'boolean',
+                },
+                {
+                    default: false,
+                    description: 'If --render cannot find any browser, auto-install Playwright chromium (one-time ~170 MB download).',
+                    flag: '--install-browser',
+                    type: 'boolean',
+                },
+                {
+                    default: true,
+                    description: 'After a multi-page crawl, remove any .md or image files inside <outDir>/pages and <outDir>/images that were not written by this run. Disable with --no-prune to preserve old files.',
+                    flag: '--prune',
+                    type: 'boolean',
+                },
+                {
+                    default: false,
+                    description: 'Skip confirmation prompts',
+                    flag: '--noConfirm',
+                    type: 'boolean',
+                },
+            ],
+        })) {
+            return 'crawl';
+        }
+        tools.nonInteractiveHint('lt tools crawl <url> --out <dir> --depth 1 --noConfirm');
+        const ltConfig = config.loadConfig();
+        const commandConfig = (_b = (_a = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _a === void 0 ? void 0 : _a.tools) === null || _b === void 0 ? void 0 : _b.crawl;
+        // URL: positional argument > --url > interactive prompt.
+        const urlInput = parameters.first ||
+            parameters.options.url ||
+            (yield helper.getInput(undefined, { name: 'Website URL', showError: false }));
+        if (!urlInput) {
+            error('No URL provided');
+            return;
+        }
+        const url = normalizeSeedUrl(urlInput);
+        try {
+            new URL(url);
+        }
+        catch (_f) {
+            error(`Invalid URL: ${urlInput}`);
+            return;
+        }
+        const depthRaw = config.getValue({
+            // `--all` is a convenience shortcut for `--depth all`. It wins
+            // over a numeric `--depth` so users can combine both.
+            cliValue: parameters.options.all === true ? 'all' : parameters.options.depth,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.depth,
+            defaultValue: 0,
+        });
+        const depth = parseDepth(depthRaw);
+        const includeImages = config.getValue({
+            cliValue: parameters.options.images === false ? false : undefined,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.includeImages,
+            defaultValue: true,
+        });
+        const includeSitemap = config.getValue({
+            cliValue: parameters.options.sitemap === false ? false : undefined,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.includeSitemap,
+            defaultValue: true,
+        });
+        const concurrency = Number(config.getValue({
+            cliValue: parameters.options.concurrency,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.concurrency,
+            defaultValue: 4,
+        }));
+        const maxPages = Number(config.getValue({
+            cliValue: (_c = parameters.options.maxPages) !== null && _c !== void 0 ? _c : parameters.options['max-pages'],
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.maxPages,
+            defaultValue: 200,
+        }));
+        const timeout = Number(config.getValue({
+            cliValue: parameters.options.timeout,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.timeout,
+            defaultValue: 20000,
+        }));
+        const selector = config.getValue({
+            cliValue: parameters.options.selector,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.selector,
+        });
+        // `--render` and `--prune` default ON — the common case is a
+        // full SPA-aware knowledge-base crawl that stays in sync on
+        // updates. `--no-render` / `--no-prune` opt out explicitly.
+        const renderJs = config.getValue({
+            cliValue: parameters.options.render === false ? false : undefined,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.renderJs,
+            defaultValue: true,
+        });
+        const installBrowser = parameters.options['install-browser'] === true || parameters.options.installBrowser === true;
+        const pruneOrphans = config.getValue({
+            cliValue: parameters.options.prune === false ? false : undefined,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.prune,
+            defaultValue: true,
+        });
+        const outDir = (0, path_1.resolve)(config.getValue({
+            cliValue: (_d = parameters.options.out) !== null && _d !== void 0 ? _d : parameters.options.output,
+            configValue: commandConfig === null || commandConfig === void 0 ? void 0 : commandConfig.out,
+            defaultValue: filesystem.cwd(),
+        }) || filesystem.cwd());
+        const noConfirm = config.getNoConfirm({
+            cliValue: parameters.options.noConfirm,
+            commandConfig,
+            config: ltConfig,
+            parentConfig: (_e = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _e === void 0 ? void 0 : _e.tools,
+        });
+        info('');
+        info(`Crawling: ${url}`);
+        info(`Output:   ${outDir}`);
+        info(`Depth:    ${depth === 'all' ? 'all (bounded by --max-pages)' : depth}`);
+        info(`Sitemap:  ${includeSitemap ? 'yes' : 'no'}`);
+        info(`Images:   ${includeImages ? 'yes' : 'no'}`);
+        info(`Parallel: ${concurrency}`);
+        info(`Max:      ${maxPages} pages`);
+        info(`Render:   ${renderJs ? 'yes (headless browser)' : 'no (raw HTTP)'}`);
+        info(`Prune:    ${pruneOrphans ? 'yes (remove orphaned pages/images)' : 'no'}`);
+        if (selector)
+            info(`Selector: ${selector}`);
+        info('');
+        if (!noConfirm && !(yield confirm('Start crawl?'))) {
+            return 'crawl cancelled';
+        }
+        const spinner = spin('Crawling...');
+        const result = yield (0, crawler_1.crawlSite)({
+            autoInstallBrowser: installBrowser,
+            concurrency,
+            depth,
+            includeImages,
+            includeSitemap,
+            maxPages,
+            onLog: (msg) => {
+                spinner.text = msg;
+            },
+            outDir,
+            prune: pruneOrphans,
+            renderJs,
+            selector,
+            timeout,
+            url,
+        }).catch((err) => {
+            spinner.fail('Crawl failed');
+            error(err.message);
+            return null;
+        });
+        if (!result) {
+            return;
+        }
+        spinner.succeed(`Crawl complete: ${result.pages.length} page(s)`);
+        info('');
+        if (result.indexFile) {
+            success(`Overview: ${result.indexFile}`);
+        }
+        for (const page of result.pages.slice(0, 10)) {
+            info(`  - ${page.relativePath}  (${page.url})`);
+        }
+        if (result.pages.length > 10) {
+            info(`  ... and ${result.pages.length - 10} more`);
+        }
+        if (result.pruned.length > 0) {
+            info(`Pruned ${result.pruned.length} orphaned file(s)`);
+            for (const path of result.pruned.slice(0, 5)) {
+                info(`  - ${path}`);
+            }
+            if (result.pruned.length > 5)
+                info(`  ... and ${result.pruned.length - 5} more`);
+        }
+        if (result.skipped.length > 0) {
+            warning(`Skipped ${result.skipped.length} URL(s) (non-HTML or foreign origin)`);
+        }
+        if (result.errors.length > 0) {
+            warning(`${result.errors.length} error(s):`);
+            for (const err of result.errors.slice(0, 5)) {
+                warning(`  - ${err.url}: ${err.reason}`);
+            }
+        }
+        if (!toolbox.parameters.options.fromGluegunMenu) {
+            process.exit();
+        }
+        return `crawled ${result.pages.length} pages`;
+    }),
+};
+function normalizeSeedUrl(raw) {
+    const trimmed = raw.trim();
+    if (/^https?:\/\//i.test(trimmed))
+        return trimmed;
+    return `https://${trimmed}`;
+}
+/**
+ * Parse the --depth parameter. Accepts positive integers, the string
+ * "all", and negative values (treated as "all"). Invalid values fall
+ * back to `0` so the crawl still runs against the seed URL.
+ */
+function parseDepth(raw) {
+    if (raw === undefined || raw === null)
+        return 0;
+    if (typeof raw === 'string') {
+        const normalized = raw.trim().toLowerCase();
+        if (normalized === 'all' || normalized === '-1')
+            return 'all';
+        const n = Number(normalized);
+        if (!Number.isFinite(n))
+            return 0;
+        return n < 0 ? 'all' : Math.floor(n);
+    }
+    if (typeof raw === 'number') {
+        if (!Number.isFinite(raw))
+            return 'all';
+        return raw < 0 ? 'all' : Math.floor(raw);
+    }
+    return 0;
+}
+exports.default = NewCommand;

package/build/config/vendor-runtime-deps.json

@@ -1,9 +1,5 @@
 {
   "$schema": "./vendor-runtime-deps.schema.json",
   "description": "Upstream @lenne.tech/nest-server devDependencies that are actually needed at runtime in a consumer project. When vendoring, these entries are promoted from upstream devDependencies into the project's dependencies so production runtime has them available.",
-  "runtimeHelpers": [
-    "find-file-up"
-  ]
+  "runtimeHelpers": ["find-file-up"]
 }
-</content>
-</invoke>

package/build/extensions/api-mode.js

@@ -55,6 +55,50 @@ class ApiMode {
             this.filesystem.remove((0, path_1.join)(projectPath, 'scripts', 'strip-api-mode-markers.mjs'));
             // Remove strip-markers script from package.json
             this.removeScriptFromPackageJson(projectPath, 'strip-markers');
+            // NOTE: auto-format of the stripped files happens separately in
+            // `formatProject()`, which MUST be called by the caller AFTER
+            // `pnpm install`. At this point the project's formatter (oxfmt) is
+            // not yet on disk, so running it here would silently no-op.
+        });
+    }
+    /**
+     * Run the project's `format` (or `format:fix`) npm script, if it exists.
+     * Call this AFTER the project's dependencies have been installed —
+     * otherwise the formatter (e.g. oxfmt) isn't available yet and the
+     * pass silently no-ops.
+     *
+     * Used after region stripping to normalize whitespace artifacts the
+     * formatter would otherwise flag in `format:check` (e.g. collapsing
+     * `providers: [\n  X,\n]` to `providers: [X]` once graphql items were
+     * removed). Failures are non-fatal so a misbehaving formatter never
+     * blocks init.
+     */
+    formatProject(projectPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const pkgPath = (0, path_1.join)(projectPath, 'package.json');
+            const pkgRaw = this.filesystem.read(pkgPath);
+            if (!pkgRaw)
+                return;
+            let pkg;
+            try {
+                pkg = JSON.parse(pkgRaw);
+            }
+            catch (_d) {
+                return;
+            }
+            const scripts = (_a = pkg.scripts) !== null && _a !== void 0 ? _a : {};
+            const formatScript = scripts.format ? 'format' : scripts['format:fix'] ? 'format:fix' : null;
+            if (!formatScript)
+                return;
+            const { pm, system } = this.toolbox;
+            const runner = (_c = (_b = pm === null || pm === void 0 ? void 0 : pm.run) === null || _b === void 0 ? void 0 : _b.call(pm, formatScript, pm.detect(projectPath))) !== null && _c !== void 0 ? _c : `pnpm run ${formatScript}`;
+            try {
+                yield system.run(`cd "${projectPath}" && ${runner}`);
+            }
+            catch (_e) {
+                // Non-fatal: the user can run format manually if this misbehaves.
+            }
         });
     }
     /**
@@ -143,13 +187,77 @@ class ApiMode {
                 if (!content) {
                     continue;
                 }
-                const processed = this.processFileRegions(content, removeMarker, keepMarker);
+                // Special-case config.env.ts in REST mode: simply deleting the
+                // `graphQl: { … }` property is not enough — `CoreModule.forRoot`
+                // treats `graphQl === undefined` as enabled and tries to build
+                // the GraphQL schema anyway (which then fails on core models
+                // like CoreHealthCheckResult that reference the JSON scalar).
+                // Replace each stripped `// #region graphql … // #endregion
+                // graphql` block with an explicit `graphQl: false,` so GraphQL
+                // is cleanly disabled.
+                let processed;
+                if (removeMarker === 'graphql' && file.endsWith('/config.env.ts')) {
+                    processed = this.replaceGraphqlRegionsWithDisabled(content, keepMarker);
+                }
+                else {
+                    processed = this.processFileRegions(content, removeMarker, keepMarker);
+                }
                 if (processed !== content) {
                     this.filesystem.write(file, processed);
                 }
             }
         }
     }
+    /**
+     * Like `processFileRegions` with removeMarker='graphql', but a
+     * stripped region that contains a `graphQl:` property assignment is
+     * replaced with `graphQl: false,` (at the region's indent) instead of
+     * being deleted outright. Other graphql-regions (e.g. wrapping
+     * `execAfterInit: 'pnpm run docs:bootstrap'`) are deleted as usual.
+     *
+     * Rationale: `CoreModule.forRoot` treats `options.graphQl === undefined`
+     * as enabled, so dropping the property silently keeps GraphQL active
+     * and later crashes when the schema references scalars that were
+     * purged in REST mode.
+     *
+     * Preserves keepMarker behaviour (strip marker lines only, keep content).
+     */
+    replaceGraphqlRegionsWithDisabled(content, keepMarker) {
+        const lines = content.split('\n');
+        const result = [];
+        let inRegion = false;
+        let regionIndent = '';
+        let regionBuffer = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed === '// #region graphql') {
+                inRegion = true;
+                regionIndent = line.slice(0, line.indexOf('//'));
+                regionBuffer = [];
+                continue;
+            }
+            if (trimmed === '// #endregion graphql') {
+                inRegion = false;
+                // Only emit a replacement if the stripped block actually
+                // contained a `graphQl:` assignment.
+                if (regionBuffer.some((l) => /\bgraphQl\s*:/.test(l))) {
+                    result.push(`${regionIndent}graphQl: false,`);
+                }
+                regionBuffer = [];
+                continue;
+            }
+            if (inRegion) {
+                regionBuffer.push(line);
+                continue;
+            }
+            // Keep-marker lines (e.g. `// #region rest`) are dropped; content between them stays.
+            if (trimmed === `// #region ${keepMarker}` || trimmed === `// #endregion ${keepMarker}`) {
+                continue;
+            }
+            result.push(line);
+        }
+        return result.join('\n');
+    }
     /**
      * Process region markers in file content
      */
@@ -261,8 +369,20 @@ class ApiMode {
             }
             catch (_b) {
                 // If ts-morph is not available or fails, fall back to regex
-                this.modifyConfigEnvForRestFallback(projectPath);
             }
+            // Safety net: always run the regex fallback too. ts-morph only
+            // traverses direct ObjectLiteralExpression properties, so configs
+            // that wrap env-blocks in helper functions (e.g. `local:
+            // localConfig(...)`) are skipped silently. The regex is idempotent
+            // — if ts-morph already replaced `graphQl: {...}` with
+            // `graphQl: false` it's a no-op, but if ts-morph missed a wrapped
+            // occurrence the regex catches it. Without this, REST-mode
+            // projects built from a starter that lacks explicit
+            // `// #region graphql` markers would end up with `graphQl:
+            // undefined`, which `CoreModule.forRoot` treats as ENABLED, and
+            // the GraphQL schema build crashes on core models that still
+            // reference the JSON scalar.
+            this.modifyConfigEnvForRestFallback(projectPath);
         });
     }
     /**
@@ -389,9 +509,7 @@ class ApiMode {
                 importLineSet.add(j);
             }
         }
-        const codeContent = lines
-            .map((line, idx) => (importLineSet.has(idx) ? '' : line))
-            .join('\n');
+        const codeContent = lines.map((line, idx) => (importLineSet.has(idx) ? '' : line)).join('\n');
         // Check each import
         const linesToRemove = new Set();
         for (const imp of importLines) {