@lenne.tech/cli 1.41.3 → 1.43.0

package/build/lib/strip-vendor-schema-augmentation.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAugmentationBlocks = stripAugmentationBlocks;
+exports.stripVendorSchemaAugmentation = stripVendorSchemaAugmentation;
+const fs_utils_1 = require("./fs-utils");
+/**
+ * Drop `declare module '<nuxt|@nuxt>/schema' { … }` blocks that only augment
+ * `PublicRuntimeConfig`, leaving a note in their place.
+ *
+ * Brace-counted rather than regex-matched to the closing brace: a block may grow
+ * more members, and a pattern pinned to today's exact two lines would silently
+ * stop matching the moment it does — reintroducing the bug with no test failing,
+ * because the symptom only appears in a generated project.
+ *
+ * A block that augments anything OTHER than `PublicRuntimeConfig` is left alone.
+ * Those carry real declarations (module options, hooks) with no cycle, and
+ * deleting them would trade a typing bug for a worse one.
+ */
+function stripAugmentationBlocks(source, onSkip) {
+    const OPEN = /declare module ['"](?:@nuxt|nuxt)\/schema['"]\s*\{/g;
+    let out = source;
+    // A forward cursor rather than restarting `exec` from 0 after every rewrite.
+    // The restart made the matching branch O(k²) in the block count — measured
+    // 40 ms at 400 blocks, 558 ms at 1600. Real input is k=2, so this is shape
+    // rather than cost; the cursor is simply the honest way to write it, and it
+    // removes the recursion the non-matching branch needed.
+    let searchFrom = 0;
+    for (;;) {
+        OPEN.lastIndex = searchFrom;
+        const match = OPEN.exec(out);
+        if (!match)
+            break;
+        const bodyStart = match.index + match[0].length;
+        const end = matchingBrace(out, bodyStart);
+        if (end === -1) {
+            // Unbalanced (or a brace the scanner could not follow). Leaving it is the
+            // safe direction — truncating would break the file — but it must NOT be
+            // silent: the augmentation stays, so `config.public.*` is `unknown` in the
+            // generated project and nothing said so. Report and stop.
+            onSkip === null || onSkip === void 0 ? void 0 : onSkip("could not find the end of a `declare module '…/schema'` block; the augmentation was left in place. " +
+                'Remove it by hand, or `config.public.*` will type as `unknown` in this project.');
+            break;
+        }
+        const body = out.slice(bodyStart, end);
+        if (!/\bPublicRuntimeConfig\b/.test(body) || /\binterface\s+(?!PublicRuntimeConfig\b)/.test(body)) {
+            // Not ours, or carries other declarations too — keep it and move past it.
+            searchFrom = end + 1;
+            continue;
+        }
+        const note = '// The `nuxt/schema` PublicRuntimeConfig augmentation was removed by `lt` when this\n' +
+            '// core was vendored. In node_modules it is harmless; as project source it augments\n' +
+            '// the same interface twice (`nuxt/schema` re-exports `@nuxt/schema`) and closes a\n' +
+            "// cycle with Nuxt's generated runtime-config types — TS2310, hidden by skipLibCheck,\n" +
+            '// which makes every `config.public.*` read `unknown`. The keys are unaffected: Nuxt\n' +
+            "// writes them into the generated types from the module's runtime-config defaults.\n" +
+            '// Do not restore it here; fix it upstream in @lenne.tech/nuxt-extensions.';
+        out = `${out.slice(0, match.index)}${note}${out.slice(end + 1)}`;
+        searchFrom = match.index + note.length;
+    }
+    return out;
+}
+/**
+ * Remove the `nuxt/schema` runtime-config augmentations from a vendored
+ * nuxt-extensions core.
+ *
+ * ## What breaks without this
+ *
+ * `runtime/types/module.ts` in nuxt-extensions ends with:
+ *
+ *     declare module 'nuxt/schema'  { interface PublicRuntimeConfig extends LtExtensionsPublicRuntimeConfig {} }
+ *     declare module '@nuxt/schema' { interface PublicRuntimeConfig extends LtExtensionsPublicRuntimeConfig {} }
+ *
+ * In npm mode that file ships as a `.d.ts` inside `node_modules` and never
+ * enters the consumer's TypeScript program. Vendoring copies it to
+ * `app/core/runtime/types/module.ts`, which the project's own `include` picks up
+ * unconditionally — and `nuxt/schema` re-exports `@nuxt/schema`, so augmenting
+ * both names decorates ONE interface twice. Nuxt's generated
+ * `.nuxt/types/runtime-config.d.ts` then closes the loop with its own
+ * `interface PublicRuntimeConfig extends UserPublicRuntimeConfig` (imported from
+ * `nuxt/schema`), and TypeScript reports:
+ *
+ *     .nuxt/types/runtime-config.d.ts: error TS2310:
+ *       Type 'PublicRuntimeConfig' recursively references itself as a base type.
+ *
+ * An interface in that state resolves every member to `unknown`. So in every
+ * vendor-mode project — the DEFAULT for `lt fullstack init` — `config.public.x`
+ * is `unknown` rather than its declared type, and `nuxt typecheck` fails on
+ * ordinary, correct code.
+ *
+ * ## Why it took so long to find
+ *
+ * Nuxt sets `skipLibCheck: true`, which suppresses TS2310 because it is reported
+ * in a `.d.ts`. The cause is therefore invisible and only the consequence shows:
+ * a plain `Argument of type 'unknown' is not assignable to parameter of type
+ * 'string'` at a call site that is not wrong. That is why the trap was previously
+ * written up as "vendor mode does not emit the schema block" — in
+ * `nuxt-base-starter/nuxt-base-template/CLAUDE.md` and in the JSDoc of that
+ * template's `app/utils/app-origin.ts`, both since corrected. The block IS
+ * emitted, and is byte-identical between the two modes (`diff` of the two
+ * generated `.nuxt/types/runtime-config.d.ts` is empty). Measured 2026-08-22 by
+ * converting the template and re-running the type gate with
+ * `--skipLibCheck false`.
+ *
+ * ## Why removing it costs nothing
+ *
+ * `ltExtensions` does not reach the consumer through this augmentation. The
+ * module sets its runtime-config defaults at build time, so Nuxt writes the whole
+ * shape into `SharedPublicRuntimeConfig` in the generated file. Verified after
+ * stripping: `config.public.ltExtensions.auth.enabled` is `boolean`,
+ * `.basePath` is `string`, `config.public.siteUrl` is `string`, and the type gate
+ * is clean.
+ *
+ * The conversion is the right owner: it is the step that turns package typings
+ * into project source, so it owns what that change of status implies.
+ *
+ * @returns the files that were modified, plus any block it could not process —
+ *          which the caller MUST surface, because a skipped block means the bug
+ *          is still there and only the transform knows it.
+ */
+function stripVendorSchemaAugmentation(options) {
+    var _a;
+    const { coreDir, filesystem } = options;
+    if (!filesystem.isDirectory(coreDir))
+        return { touched: [], warnings: [] };
+    // A linked sub-project points at the user's own checkout; rewriting files there
+    // would edit their repository. Same guard the workspace helpers already apply.
+    if ((0, fs_utils_1.isSymlink)(coreDir))
+        return { touched: [], warnings: [] };
+    const touched = [];
+    const warnings = [];
+    for (const file of (_a = filesystem.find(coreDir, { matching: '**/*.ts' })) !== null && _a !== void 0 ? _a : []) {
+        const content = filesystem.read(file);
+        if (!content || !content.includes('PublicRuntimeConfig'))
+            continue;
+        const patched = stripAugmentationBlocks(content, (reason) => {
+            warnings.push(`${file}: ${reason}`);
+        });
+        if (patched === content)
+            continue;
+        filesystem.write(file, patched);
+        touched.push(file);
+    }
+    return { touched, warnings };
+}
+/**
+ * Index of the `}` closing the block whose body starts at `from`, or -1.
+ *
+ * Skips over string literals, template literals and comments. Counting raw
+ * braces looked adequate — the augmentation bodies are two plain
+ * `interface … extends … {}` lines — but a fuzz pass found both failure modes,
+ * and both are silent:
+ *
+ * - a `}` inside a string (`{ open: '}' }`) drops depth to 0 early, so the strip
+ *   cuts mid-block and leaves a stray `}` behind. The vendored file then does not
+ *   compile, in a project the developer just generated.
+ * - a `{` inside a string (`type X = '{'`) never balances, this returns -1, the
+ *   caller stops, and the augmentation is silently RETAINED — the exact TS2310
+ *   bug the whole transform exists to remove, with nothing printed.
+ *
+ * Neither triggers on today's nuxt-extensions. But this file's own contract is
+ * that the block may grow members (that is why it counts braces instead of
+ * matching a fixed pattern), and the day a member carries a brace in a string is
+ * the day it misfires.
+ */
+function matchingBrace(text, from) {
+    let depth = 1;
+    for (let i = from; i < text.length; i++) {
+        const ch = text[i];
+        // Line comment — nothing structural until the newline.
+        if (ch === '/' && text[i + 1] === '/') {
+            const nl = text.indexOf('\n', i);
+            if (nl === -1)
+                return -1;
+            i = nl;
+            continue;
+        }
+        // Block comment.
+        if (ch === '/' && text[i + 1] === '*') {
+            const close = text.indexOf('*/', i + 2);
+            if (close === -1)
+                return -1;
+            i = close + 1;
+            continue;
+        }
+        // String or template literal. Templates may nest `${…}`, which would need a
+        // full parser to follow — so a template is treated as opaque, which is the
+        // safe direction: at worst a brace inside `${}` is ignored and the caller
+        // gets -1 and warns, rather than cutting the file in the wrong place.
+        if (ch === '"' || ch === "'" || ch === '`') {
+            const quote = ch;
+            i++;
+            while (i < text.length && text[i] !== quote) {
+                if (text[i] === '\\')
+                    i++;
+                // An unterminated single/double-quoted string cannot span a newline.
+                else if (text[i] === '\n' && quote !== '`')
+                    return -1;
+                i++;
+            }
+            if (i >= text.length)
+                return -1;
+            continue;
+        }
+        if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}

package/build/lib/vendor-claude-md.js

@@ -92,6 +92,21 @@ function buildFrontendVendorBlock() {
         '- **Contribute back:** run `/lt-dev:frontend:contribute-nuxt-extensions-core`.',
         '- **Freshness check:** `pnpm run check:vendor-freshness` warns when',
         '  upstream has a newer release than the baseline.',
+        '',
+        '**If `config.public.*` types as `unknown`** (projects vendored before lt CLI',
+        '1.43.0), check with:',
+        '',
+        '    grep -rn "declare module \'@nuxt/schema\'" app/core/',
+        '',
+        'A match means the vendored core still augments `PublicRuntimeConfig` under both',
+        '`nuxt/schema` and `@nuxt/schema`. Those are one interface (the former re-exports',
+        "the latter), and as project source they close a cycle with Nuxt's generated",
+        'runtime-config types — TS2310, which `skipLibCheck` hides, so every',
+        '`config.public.*` read silently becomes `unknown`. Delete both blocks from',
+        '`app/core/runtime/types/module.ts`; nothing is lost, because `ltExtensions`',
+        "reaches the app through the module's runtime-config defaults either way.",
+        'New conversions strip them automatically — but a core update copies upstream',
+        'verbatim, so re-run the grep after every sync.',
     ]);
 }
 /**

package/build/lib/vscode-settings.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXCLUDED_FROM_PROFILE = exports.MEMORY_PROFILE = void 0;
+exports.buildMergedValue = buildMergedValue;
+exports.detectVariants = detectVariants;
+exports.diffProfile = diffProfile;
+exports.formatChange = formatChange;
+exports.isEnablingFlagSet = isEnablingFlagSet;
+exports.isPreventingFlagSet = isPreventingFlagSet;
+exports.selectVariants = selectVariants;
+exports.settingsPathFor = settingsPathFor;
+exports.tuneSettingsFile = tuneSettingsFile;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * The tuning profile.
+ *
+ * Every value here was verified against the shipped extension manifests
+ * rather than copied from a blog post — three commonly recommended keys are
+ * deliberately ABSENT, see `EXCLUDED_FROM_PROFILE`.
+ *
+ * The exclude globs use `.nuxt*` / `.output*`, not `.nuxt` / `.output`. Both the
+ * framework and this CLI spawn SIBLING build directories — `.nuxt-check` for the
+ * check chain, `.nuxt-test` / `.output-test` for `lt dev test` — and a glob
+ * segment matches whole path segments, so `**\/.nuxt/**` does not cover
+ * `.nuxt-test`. A `.output-test` tree measures 37-294 MB; leaving it watched and
+ * indexed would undo the very saving this profile exists to make.
+ */
+exports.MEMORY_PROFILE = {
+    'files.watcherExclude': {
+        reason: 'Stops the file watcher from following build output and dependencies (CPU + memory per window).',
+        value: {
+            '**/.git/objects/**': true,
+            '**/.git/subtree-cache/**': true,
+            '**/.nuxt*/**': true,
+            '**/.output*/**': true,
+            '**/dist/**': true,
+            '**/node_modules/**': true,
+        },
+    },
+    'search.exclude': {
+        reason: 'Keeps full-text search from indexing generated trees.',
+        value: {
+            '**/.nuxt*/**': true,
+            '**/.output*/**': true,
+            '**/dist/**': true,
+            '**/node_modules/**': true,
+        },
+    },
+    'typescript.disableAutomaticTypeAcquisition': {
+        reason: 'Skips the @types download/scan pass — pointless in projects that declare their own types.',
+        value: true,
+    },
+    'typescript.preferences.includePackageJsonAutoImports': {
+        reason: 'Auto-import no longer scans every package.json in the workspace — the single biggest monorepo win.',
+        value: 'off',
+    },
+    'typescript.tsserver.maxTsServerMemory': {
+        reason: 'Lowers the per-server heap ceiling from the 3072 MB default; multiplies across every open root.',
+        value: 2048,
+    },
+};
+/**
+ * Keys intentionally NOT in the profile, with the measurement or manifest
+ * check that ruled them out. Surfaced by `lt dev vscode --explain` so the
+ * reasoning survives beyond the session that produced it.
+ */
+exports.EXCLUDED_FROM_PROFILE = [
+    {
+        key: 'typescript.tsserver.useSyntaxServer: "never"',
+        why: 'Would drop the 2nd server per root, but those measured only ~1.7 GB across 16 roots while costing editor responsiveness.',
+    },
+    {
+        key: 'vue.server.hybridMode',
+        why: 'Does not exist in Volar 3.x — hybrid mode is unconditional there. Setting it is a silent no-op.',
+    },
+    {
+        key: 'typescript.tsserver.maxTsServerMemory: 4096+',
+        why: 'v8 pointer compression caps the heap near 4 GB, so values above it are ignored (microsoft/vscode#127105).',
+    },
+];
+/**
+ * Merge semantics per value type.
+ *
+ * A plain value is replaced. An object value (the exclude maps) is merged with
+ * the user's existing entries winning, so tuning never silently drops a
+ * project-specific exclusion someone added by hand.
+ *
+ * A non-object `before` under an object-valued key (an array, say) is NOT
+ * mergeable and is replaced — VS Code's exclude settings are objects, so such a
+ * value is already being ignored by VS Code itself. That is the one case where
+ * the "never drops" promise above does not hold, and `--revert` cannot restore
+ * it either; the `.bak` is the recovery path.
+ */
+function buildMergedValue(before, desired) {
+    if (!isPlainObject(desired)) {
+        return desired;
+    }
+    if (!isPlainObject(before)) {
+        return Object.assign({}, desired);
+    }
+    return Object.assign(Object.assign({}, desired), before);
+}
+/** Every known variant, flagged by whether its settings file exists. */
+function detectVariants(platform = process.platform, home = (0, os_1.homedir)()) {
+    const known = [
+        { dir: 'Code', id: 'code', label: 'VS Code' },
+        { dir: 'Code - Insiders', id: 'insiders', label: 'VS Code Insiders' },
+        { dir: 'Cursor', id: 'cursor', label: 'Cursor' },
+        { dir: 'VSCodium', id: 'vscodium', label: 'VSCodium' },
+    ];
+    return known.map((k) => {
+        const settingsPath = settingsPathFor(k.dir, platform, home);
+        return { id: k.id, installed: (0, fs_1.existsSync)(settingsPath), label: k.label, settingsPath };
+    });
+}
+/**
+ * Compare the profile against a parsed settings object.
+ *
+ * Object-valued keys (the two exclude maps) are treated as SETS of entries in
+ * both directions: applying merges (the user's entries win), and reverting
+ * subtracts only the entries this profile contributes. Deleting the whole key on
+ * revert would take the user's hand-maintained exclusions with it — an undo that
+ * destroys data the tool never added is worse than no undo at all.
+ *
+ * Scalar keys are removed outright on revert, which restores VS Code's own
+ * default. An explicit pre-existing scalar (`maxTsServerMemory: 3072`, say) is
+ * not restored — recovering that is what the `.bak` is for.
+ */
+function diffProfile(current, remove = false) {
+    return Object.entries(exports.MEMORY_PROFILE).map(([key, entry]) => {
+        const before = current[key];
+        const after = remove ? buildRevertedValue(before, entry.value) : buildMergedValue(before, entry.value);
+        let action;
+        if (remove) {
+            action = before === undefined || sameJson(before, after) ? 'unchanged' : 'removed';
+        }
+        else if (before === undefined) {
+            action = 'added';
+        }
+        else {
+            action = sameJson(before, after) ? 'unchanged' : 'changed';
+        }
+        return { action, after, before, key };
+    });
+}
+/**
+ * One `key: before → after` line, coloured by what happens to it.
+ *
+ * Lives here rather than in the command so it can be unit-tested; it takes the
+ * colour helpers as an argument and is otherwise pure.
+ */
+function formatChange(change, colors) {
+    const short = (v) => {
+        if (v === undefined) {
+            return '—';
+        }
+        const s = JSON.stringify(v);
+        return s.length > 52 ? `${s.slice(0, 49)}…` : s;
+    };
+    const tag = {
+        added: colors.green('+'),
+        changed: colors.yellow('~'),
+        removed: colors.red('-'),
+        unchanged: colors.dim('='),
+    }[change.action];
+    if (change.action === 'unchanged') {
+        return `${tag} ${colors.dim(change.key)} ${colors.dim(short(change.before))}`;
+    }
+    return `${tag} ${change.key}: ${colors.dim(short(change.before))} → ${short(change.after)}`;
+}
+/**
+ * Whether an ENABLING flag (`--revert`, `--explain`) is set.
+ *
+ * gluegun declares no booleans to yargs-parser, so `--revert=true` arrives as
+ * the STRING `'true'`. For a flag that turns something ON, a parse quirk that
+ * reads as "not set" fails CLOSED, which is the safe direction.
+ */
+function isEnablingFlagSet(value) {
+    return value === true || value === 'true';
+}
+/**
+ * Whether a PREVENTING flag (`--dry-run`) is set.
+ *
+ * Deliberately NOT `=== true || === 'true'`. That idiom is exactly backwards for
+ * a flag whose job is to STOP a write: `--dry-run=1` parses to the number `1`
+ * and `--dry-run=yes` to a string, both of which would read as "not set" and let
+ * the write proceed — the failure mode this repo already paid for once with
+ * `--keep-db` (see CLAUDE.md). Presence is intent; only an explicit negation
+ * proceeds.
+ */
+function isPreventingFlagSet(options, ...names) {
+    return names.some((name) => {
+        if (!(name in options)) {
+            return false;
+        }
+        const v = options[name];
+        return v !== false && v !== 'false' && v !== 0 && v !== '0';
+    });
+}
+/**
+ * Split the detected variants into what to act on, given an optional `--variant`.
+ *
+ * `unknownFilter` is reported separately from "nothing installed": a bare
+ * `--variant` parses to boolean `true` and matches no id, and conflating that
+ * with "no editor found" told users VS Code was missing while it was installed.
+ */
+function selectVariants(all, filter) {
+    const installed = all.filter((v) => v.installed);
+    if (filter === undefined || filter === null) {
+        return { targets: installed };
+    }
+    const wanted = String(filter);
+    if (!all.some((v) => v.id === wanted)) {
+        return { targets: [], unknownFilter: wanted };
+    }
+    return { targets: installed.filter((v) => v.id === wanted) };
+}
+/**
+ * Absolute path to a variant's user-settings file, per platform.
+ *
+ * All VS Code forks reuse the upstream layout, only the application support
+ * directory name differs. The joiner is selected per platform rather than taken
+ * from the ambient `path`, so the Windows branch produces real Windows paths
+ * (and stays assertable) when called from a test on macOS or Linux.
+ */
+function settingsPathFor(dirName, platform = process.platform, home = (0, os_1.homedir)()) {
+    if (platform === 'win32') {
+        const appData = process.env.APPDATA || path_1.win32.join(home, 'AppData', 'Roaming');
+        return path_1.win32.join(appData, dirName, 'User', 'settings.json');
+    }
+    if (platform === 'darwin') {
+        return path_1.posix.join(home, 'Library', 'Application Support', dirName, 'User', 'settings.json');
+    }
+    return path_1.posix.join(home, '.config', dirName, 'User', 'settings.json');
+}
+/**
+ * Apply (or revert) the profile on one settings file.
+ *
+ * JSONC-safe: the file is edited through `jsonc-parser`, which preserves
+ * comments, key order and the user's formatting. A naive
+ * `JSON.parse` → `JSON.stringify` round-trip would silently delete every
+ * comment in a file people hand-maintain.
+ *
+ * `jsonc-parser` is required lazily: gluegun eagerly loads every command module
+ * on every `lt` invocation, and this is its only consumer, so a top-level import
+ * would put the load cost on `lt --version` too. Matches how the repo already
+ * treats `open`, `js-yaml`, `playwright-core` and `ts-morph`.
+ *
+ * Never writes when nothing would change, so re-running is a true no-op. Every
+ * failure is returned as `error` rather than thrown — the caller renders it per
+ * installation and carries on with the others.
+ */
+function tuneSettingsFile(settingsPath, options = {}) {
+    var _a;
+    const { dryRun = false, remove = false } = options;
+    if (!(0, fs_1.existsSync)(settingsPath)) {
+        return { changes: [], error: `settings file not found: ${settingsPath}`, settingsPath, written: false };
+    }
+    // Never write THROUGH a symlink — the target may be any file the user's
+    // account can reach, and we were asked to tune settings, not to overwrite it.
+    if (isSymbolicLink(settingsPath)) {
+        return { changes: [], error: `refusing to write through a symlink: ${settingsPath}`, settingsPath, written: false };
+    }
+    const { applyEdits, modify, parse, printParseErrorCode } = require('jsonc-parser');
+    let raw;
+    try {
+        raw = (0, fs_1.readFileSync)(settingsPath, 'utf8');
+    }
+    catch (e) {
+        return { changes: [], error: `cannot read ${settingsPath}: ${errText(e)}`, settingsPath, written: false };
+    }
+    const errors = [];
+    const current = ((_a = parse(raw, errors, { allowTrailingComma: true })) !== null && _a !== void 0 ? _a : {});
+    // Refuse to touch a file we cannot read reliably — writing into a
+    // malformed settings.json risks destroying the user's configuration.
+    if (errors.length > 0) {
+        const first = errors[0];
+        return {
+            changes: [],
+            error: `cannot parse ${settingsPath}: ${printParseErrorCode(first.error)} at offset ${first.offset}`,
+            settingsPath,
+            written: false,
+        };
+    }
+    const changes = diffProfile(current, remove);
+    const effective = changes.filter((c) => c.action !== 'unchanged');
+    if (effective.length === 0 || dryRun) {
+        return { changes, settingsPath, written: false };
+    }
+    let content = raw;
+    for (const change of effective) {
+        // `after === undefined` deletes the key; an exclude map emptied by the
+        // revert subtraction lands here too.
+        const edits = modify(content, [change.key], change.after, {
+            formattingOptions: { insertSpaces: true, tabSize: 4 },
+        });
+        content = applyEdits(content, edits);
+    }
+    // Keep the FIRST backup. It is the only record of what the file looked like
+    // before this tool ever touched it — overwriting it on a later run (notably on
+    // `--revert`, which would then back up the *tuned* file) destroys exactly the
+    // state a user reaching for the backup wants to get back to.
+    const backupPath = `${settingsPath}.bak`;
+    try {
+        if (!(0, fs_1.existsSync)(backupPath)) {
+            (0, fs_1.copyFileSync)(settingsPath, backupPath);
+        }
+        (0, fs_1.writeFileSync)(settingsPath, content, 'utf8');
+    }
+    catch (e) {
+        return { changes, error: `cannot write ${settingsPath}: ${errText(e)}`, settingsPath, written: false };
+    }
+    return { backupPath, changes, settingsPath, written: true };
+}
+/**
+ * The value a key should hold after `--revert`.
+ *
+ * For an object-valued profile entry: the user's map minus our own entries, or
+ * `undefined` when nothing of theirs remains. For anything else: `undefined`
+ * (delete the key).
+ */
+function buildRevertedValue(before, desired) {
+    if (!isPlainObject(desired) || !isPlainObject(before)) {
+        return undefined;
+    }
+    const kept = Object.fromEntries(Object.entries(before).filter(([k]) => !(k in desired)));
+    return Object.keys(kept).length > 0 ? kept : undefined;
+}
+/** Message text of an unknown thrown value. */
+function errText(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+/** Narrow to a non-null, non-array object. */
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** True when `path` is a symlink (never follows it). */
+function isSymbolicLink(path) {
+    try {
+        return (0, fs_1.lstatSync)(path).isSymbolicLink();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/** Structural equality via JSON, sufficient for the plain values in the profile. */
+function sameJson(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}

package/docs/LT-ECOSYSTEM-GUIDE.md

@@ -153,7 +153,7 @@ All code generators are **mode-aware**: In vendor mode they use relative paths t
 | Command | Purpose |
 |---------|---------|
 | `lt fullstack init` | Create fullstack monorepo (see above) |
-| `lt fullstack update` | Show mode-specific update instructions for backend AND frontend |
+| `lt fullstack update` | Show mode-specific update instructions — **and self-heal generated project scaffolding** (see `docs/commands.md`) |
 | **`lt fullstack convert-mode`** | **Convert backend AND frontend between npm and vendor mode in a single command** |
 
 **Fullstack mode conversion in one command:**

package/docs/VENDOR-MODE-WORKFLOW.md

@@ -443,6 +443,41 @@ git commit -m "chore: revert fullstack to npm mode
 
 ## Troubleshooting
 
+### Problem: `config.public.*` is `unknown` in a project vendored before 1.43.0
+
+**Symptom.** `nuxt typecheck` fails with `Argument of type 'unknown' is not
+assignable to parameter of type 'string'` on code that is correct, at any
+`useRuntimeConfig().public.x` read.
+
+**Check whether you are affected** — version-independent:
+
+```bash
+grep -rn "declare module '@nuxt/schema'" projects/app/app/core/
+```
+
+**Cause.** The vendored nuxt-extensions core augments `PublicRuntimeConfig` under
+both `nuxt/schema` and `@nuxt/schema`. The former re-exports the latter, so that
+is one interface decorated twice; as project source it closes a cycle with Nuxt's
+generated runtime-config types. TypeScript reports
+`TS2310: Type 'PublicRuntimeConfig' recursively references itself as a base type`,
+which Nuxt's `skipLibCheck: true` suppresses — so only the confusing symptom is
+visible. See it with:
+
+```bash
+cd projects/app && npx vue-tsc --noEmit -p .nuxt-check/tsconfig.json --skipLibCheck false | grep TS2310
+```
+
+**Repair.** Delete the two `declare module '…/schema'` blocks from
+`projects/app/app/core/runtime/types/module.ts`. Nothing is lost — `ltExtensions`
+reaches the consumer through the module's runtime-config defaults, which Nuxt
+writes into the generated types either way.
+
+New conversions strip the blocks automatically (`stripVendorSchemaAugmentation`).
+**Re-check after every core update:** the updater copies upstream files verbatim
+and would bring them back. The template's own `CLAUDE.md` carries the same repair
+note for the project side.
+
+
 ### Problem: `tsc` fails with `new Error('msg', { cause })` error
 
 **Cause:** TypeScript target is too old (ES2020 or lower).