@lenne.tech/cli 1.9.5 → 1.10.0

package/build/extensions/server.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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) {
@@ -10,9 +43,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Server = void 0;
-const crypto = require("crypto");
+const crypto = __importStar(require("crypto"));
 const path_1 = require("path");
-const ts = require("typescript");
+const ts = __importStar(require("typescript"));
 /**
  * Server helper functions
  */
@@ -222,7 +255,25 @@ class Server {
     }
     useDefineForClassFieldsActivated() {
         var _a;
-        const tsConfigPath = this.filesystem.resolve('tsconfig.json');
+        // Walk UP from the current working directory to find the nearest
+        // tsconfig.json. gluegun's `filesystem.resolve('tsconfig.json')` resolves
+        // relative to cwd without checking existence, so it breaks when `lt
+        // server module` is invoked from inside `src/` (where no tsconfig lives)
+        // — it would then silently return `false`, causing the generator to
+        // emit class fields without the `override` modifier that the project's
+        // `noImplicitOverride` rule requires.
+        const path = require('path');
+        let current = this.filesystem.cwd();
+        const root = path.parse(current).root;
+        let tsConfigPath = null;
+        while (current && current !== root) {
+            const candidate = path.join(current, 'tsconfig.json');
+            if (this.filesystem.exists(candidate)) {
+                tsConfigPath = candidate;
+                break;
+            }
+            current = path.dirname(current);
+        }
         if (tsConfigPath) {
             const readConfig = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
             if (!readConfig.error) {
@@ -581,7 +632,7 @@ class Server {
     setupServer(dest, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const { apiMode: apiModeHelper, patching, system, template, templateHelper } = this.toolbox;
-            const { apiMode, author = '', branch, copyPath, description = '', linkPath, name, projectDir, skipInstall = false, skipPatching = false, } = options;
+            const { apiMode, author = '', branch, copyPath, description = '', frameworkMode = 'npm', frameworkUpstreamBranch, linkPath, name, projectDir, skipInstall = false, skipPatching = false, } = options;
             // Setup template
             const result = yield templateHelper.setup(dest, {
                 branch,
@@ -644,6 +695,27 @@ class Server {
                 this.filesystem.remove(`${dest}/.yalc`);
                 this.filesystem.remove(`${dest}/yalc.lock`);
             }
+            // Vendor-mode transformation — identical to setupServerForFullstack, so
+            // a standalone `lt server create --framework-mode vendor` produces the
+            // same project layout as `lt fullstack init --framework-mode vendor`.
+            // Essentials list is captured BEFORE processApiMode deletes the
+            // manifest (same dance as in setupServerForFullstack).
+            let standaloneVendorUpstreamDeps = {};
+            let standaloneVendorCoreEssentials = [];
+            if (frameworkMode === 'vendor') {
+                try {
+                    const converted = yield this.convertCloneToVendored({
+                        dest,
+                        projectName: name,
+                        upstreamBranch: frameworkUpstreamBranch,
+                    });
+                    standaloneVendorUpstreamDeps = converted.upstreamDeps;
+                }
+                catch (err) {
+                    return { method: result.method, path: dest, success: false };
+                }
+                standaloneVendorCoreEssentials = this.readApiModeGraphqlEssentials(dest);
+            }
             // Process API mode (before install so package.json is correct)
             if (apiMode) {
                 try {
@@ -653,6 +725,21 @@ class Server {
                     return { method: result.method, path: dest, success: false };
                 }
             }
+            // Restore core essentials after processApiMode stripped them (vendor + REST only).
+            if (frameworkMode === 'vendor' && apiMode === 'Rest') {
+                try {
+                    this.restoreVendorCoreEssentials({
+                        dest,
+                        essentials: standaloneVendorCoreEssentials,
+                        upstreamDeps: standaloneVendorUpstreamDeps,
+                    });
+                }
+                catch (_a) {
+                    // Non-fatal.
+                }
+            }
+            // Patch CLAUDE.md with API mode info
+            this.patchClaudeMdApiMode(dest, apiMode);
             // Install packages
             if (!skipInstall) {
                 try {
@@ -676,7 +763,21 @@ class Server {
     setupServerForFullstack(dest, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const { apiMode: apiModeHelper, templateHelper } = this.toolbox;
-            const { apiMode, branch, copyPath, linkPath, name, projectDir } = options;
+            const { apiMode, branch, copyPath, frameworkMode = 'npm', frameworkUpstreamBranch, linkPath, name, projectDir, } = options;
+            // Both npm and vendor mode clone nest-server-starter as the base. The
+            // starter ships the minimal consumer conventions a project needs
+            // (src/server/common/models/persistence.model.ts, src/server/modules/user/,
+            // file/, meta/, tests/, migrations/, env files, etc.).
+            //
+            // In vendor mode we additionally clone @lenne.tech/nest-server to
+            // obtain the framework `core/` tree, copy it into the project at
+            // src/core/ (with the flatten-fix), remove the `@lenne.tech/nest-server`
+            // npm dependency, merge its transitive deps into the project
+            // package.json, and run a codemod that rewrites every
+            // `from '@lenne.tech/nest-server'` import to a relative path pointing
+            // at the vendored core.
+            //
+            // See convertCloneToVendored() below for the exact transformation.
             // Setup template
             const result = yield templateHelper.setup(dest, {
                 branch,
@@ -714,6 +815,38 @@ class Server {
                 this.filesystem.remove(`${dest}/.yalc`);
                 this.filesystem.remove(`${dest}/yalc.lock`);
             }
+            // Vendor-mode transformation: strip framework-internal content and wire
+            // the remaining files so they behave like a project that consumed the
+            // framework's core/ directory directly. Idempotent; safe to skip in
+            // npm mode.
+            //
+            // We capture the framework package.json snapshot from the temp clone so
+            // the post-apiMode step can restore upstream-declared core essentials
+            // without hard-coding package lists.
+            let vendorUpstreamDeps = {};
+            let vendorCoreEssentials = [];
+            if (frameworkMode === 'vendor') {
+                try {
+                    const converted = yield this.convertCloneToVendored({
+                        dest,
+                        projectName: name,
+                        upstreamBranch: frameworkUpstreamBranch,
+                    });
+                    vendorUpstreamDeps = converted.upstreamDeps;
+                }
+                catch (err) {
+                    return { method: result.method, path: dest, success: false };
+                }
+                // Read the graphql-only package list from the starter's
+                // api-mode.manifest.json BEFORE processApiMode runs and deletes it.
+                // These are exactly the packages processApiMode will strip in REST
+                // mode — and in vendor mode they must come back afterwards, because
+                // src/core/** still imports them even when the consumer project is
+                // REST-only (e.g. PubSub in core-auth.module.ts, GraphQLUpload in
+                // core-file.service.ts). List is dynamic; new additions surface
+                // automatically.
+                vendorCoreEssentials = this.readApiModeGraphqlEssentials(dest);
+            }
             // Process API mode (before install which happens at monorepo level)
             if (apiMode) {
                 try {
@@ -723,9 +856,938 @@ class Server {
                     return { method: result.method, path: dest, success: false };
                 }
             }
+            // In vendor mode + REST, re-add the graphql essentials that
+            // processApiMode just stripped. Both and GraphQL keep all packages
+            // by construction and don't need restoration.
+            if (frameworkMode === 'vendor' && apiMode === 'Rest') {
+                try {
+                    this.restoreVendorCoreEssentials({
+                        dest,
+                        essentials: vendorCoreEssentials,
+                        upstreamDeps: vendorUpstreamDeps,
+                    });
+                }
+                catch (err) {
+                    // Non-fatal — install may still succeed if the core never imports
+                    // the restored packages at the current version.
+                }
+            }
+            // Patch CLAUDE.md with API mode info
+            this.patchClaudeMdApiMode(dest, apiMode);
             return { method: result.method, path: dest, success: true };
         });
     }
+    /**
+     * Converts a freshly cloned `nest-server-starter` working tree into a
+     * vendored-mode consumer project.
+     *
+     * The starter ships all consumer conventions a project needs (a
+     * working `src/server/` with `common/models/persistence.model.ts`,
+     * `modules/user/`, `modules/file/`, `modules/meta/`, sample tests,
+     * migrations, env files). In npm mode it relies on the
+     * `@lenne.tech/nest-server` npm dependency to provide the framework
+     * source via `node_modules/@lenne.tech/nest-server/dist/**`.
+     *
+     * In vendor mode we additionally clone `@lenne.tech/nest-server` to
+     * /tmp, copy its framework kernel (`src/core/`, `src/index.ts`,
+     * `src/core.module.ts`, `src/test/`, `src/templates/`, `src/types/`,
+     * `LICENSE`, `bin/migrate.js`) into the project at `src/core/`
+     * applying the flatten-fix, remove `@lenne.tech/nest-server` from the
+     * project's `package.json`, merge the framework's transitive deps into
+     * the project's own deps, and run an AST-based codemod that rewrites
+     * every `from '@lenne.tech/nest-server'` import in consumer code
+     * (src/server, src/main.ts, tests/, migrations/, scripts/) to a
+     * relative path pointing at the vendored `src/core/`.
+     *
+     * The resulting tree matches the layout produced by the imo vendoring
+     * pilot, so the `nest-server-core-updater` and
+     * `nest-server-core-contributor` agents work without any further
+     * post-processing.
+     *
+     * Idempotent — running twice is a no-op.
+     */
+    convertCloneToVendored(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dest, upstreamBranch, upstreamRepoUrl = 'https://github.com/lenneTech/nest-server.git' } = options;
+            const filesystem = this.filesystem;
+            const { system } = this.toolbox;
+            const os = require('os');
+            const path = require('path');
+            const { Project, SyntaxKind } = require('ts-morph');
+            const srcDir = `${dest}/src`;
+            const coreDir = `${srcDir}/core`;
+            // ── 1. Clone @lenne.tech/nest-server into a temp directory ───────────
+            //
+            // We clone the framework repo shallowly to get the `src/core/` tree,
+            // `bin/migrate.js`, and associated meta files. The clone lives in a
+            // throw-away tmp dir that gets cleaned up at the end.
+            const tmpClone = path.join(os.tmpdir(), `lt-vendor-nest-server-${Date.now()}`);
+            const branchArg = upstreamBranch ? `--branch ${upstreamBranch} ` : '';
+            try {
+                yield system.run(`git clone --depth 1 ${branchArg}${upstreamRepoUrl} ${tmpClone}`);
+            }
+            catch (err) {
+                // Clone failures usually boil down to one of four causes — network,
+                // auth, unknown ref, or a pre-existing tmp dir. Give the user a
+                // pointed error message rather than the raw `git clone` stderr.
+                const raw = err.message || '';
+                const hints = [];
+                if (/Could not resolve host|getaddrinfo|ECONNREFUSED|Network is unreachable/i.test(raw)) {
+                    hints.push('Network issue reaching github.com — check your connection or proxy settings.');
+                }
+                if (/Permission denied|authentication failed|publickey|403|401/i.test(raw)) {
+                    hints.push('Authentication issue — the CLI uses an anonymous HTTPS clone; verify GitHub is reachable.');
+                }
+                if (upstreamBranch && /Remote branch .* not found|did not match any file\(s\) known to git/i.test(raw)) {
+                    hints.push(`Upstream ref "${upstreamBranch}" does not exist. Check ${upstreamRepoUrl}/tags or /branches for valid refs. ` +
+                        'Note: nest-server tags have NO "v" prefix — use e.g. "11.24.1", not "v11.24.1".');
+                }
+                if (/already exists and is not an empty/i.test(raw)) {
+                    hints.push(`Target directory ${tmpClone} already exists. This usually indicates a stale previous run — rm -rf /tmp/lt-vendor-nest-server-* and retry.`);
+                }
+                const hintBlock = hints.length > 0 ? `\n  Hints:\n    - ${hints.join('\n    - ')}` : '';
+                throw new Error(`Failed to clone ${upstreamRepoUrl}${upstreamBranch ? ` (branch/tag: ${upstreamBranch})` : ''}.\n  Raw git error: ${raw.trim()}${hintBlock}`);
+            }
+            // Snapshot upstream package.json before cleanup so we can merge its
+            // transitive deps into the project's package.json (step 5 below).
+            let upstreamDeps = {};
+            let upstreamDevDeps = {};
+            let upstreamVersion = '';
+            try {
+                const upstreamPkg = filesystem.read(`${tmpClone}/package.json`, 'json');
+                if (upstreamPkg && typeof upstreamPkg === 'object') {
+                    upstreamDeps = upstreamPkg.dependencies || {};
+                    upstreamDevDeps = upstreamPkg.devDependencies || {};
+                    upstreamVersion = upstreamPkg.version || '';
+                }
+            }
+            catch (_a) {
+                // Best-effort — if we can't read upstream pkg, the starter's own
+                // deps should still cover most of the framework's needs.
+            }
+            // Snapshot the upstream commit SHA for traceability in VENDOR.md.
+            let upstreamCommit = '';
+            try {
+                const sha = yield system.run(`git -C ${tmpClone} rev-parse HEAD`);
+                upstreamCommit = (sha || '').trim();
+            }
+            catch (_b) {
+                // Non-fatal — VENDOR.md will just show an empty SHA.
+            }
+            try {
+                // ── 2. Copy framework kernel into project src/core/ (flatten-fix) ──
+                //
+                // Upstream layout: src/core/ (framework sub-dir) + src/index.ts +
+                // src/core.module.ts + src/test/ + src/templates/ + src/types/.
+                // Target layout: everything flat under <project>/src/core/.
+                //
+                // We WIPE the starter's (non-existent in npm mode) src/core/ first
+                // just to guarantee idempotency when users run this twice.
+                if (filesystem.exists(coreDir)) {
+                    filesystem.remove(coreDir);
+                }
+                const copies = [
+                    [`${tmpClone}/src/core`, coreDir],
+                    [`${tmpClone}/src/index.ts`, `${coreDir}/index.ts`],
+                    [`${tmpClone}/src/core.module.ts`, `${coreDir}/core.module.ts`],
+                    [`${tmpClone}/src/test`, `${coreDir}/test`],
+                    [`${tmpClone}/src/templates`, `${coreDir}/templates`],
+                    [`${tmpClone}/src/types`, `${coreDir}/types`],
+                    [`${tmpClone}/LICENSE`, `${coreDir}/LICENSE`],
+                ];
+                for (const [from, to] of copies) {
+                    if (filesystem.exists(from)) {
+                        filesystem.copy(from, to);
+                    }
+                }
+                // Copy bin/migrate.js so the project has a working migrate CLI
+                // independent of node_modules/@lenne.tech/nest-server.
+                if (filesystem.exists(`${tmpClone}/bin/migrate.js`)) {
+                    filesystem.copy(`${tmpClone}/bin/migrate.js`, `${dest}/bin/migrate.js`);
+                }
+                // Copy migration-guides for vendor-sync agent reference (optional
+                // but useful — small overhead, big value for the updater agent).
+                if (filesystem.exists(`${tmpClone}/migration-guides`)) {
+                    filesystem.copy(`${tmpClone}/migration-guides`, `${dest}/migration-guides`);
+                }
+            }
+            finally {
+                // Always clean up the temp clone, even if copy fails midway.
+                if (filesystem.exists(tmpClone)) {
+                    filesystem.remove(tmpClone);
+                }
+            }
+            // ── 3. Apply flatten-fix rewrites on the vendored files ──────────────
+            //
+            // In `src/core/index.ts` and `src/core/core.module.ts` every relative
+            // specifier that used to be `./core/…` (when the file lived on src/)
+            // must now drop the `./core/` prefix. All OTHER internal imports
+            // within common/, modules/, etc. stay identical because their
+            // relative structure is preserved by the copy.
+            //
+            // Known edge cases from the imo pilot:
+            //   - src/core/test/test.helper.ts references '../core/common/helpers/db.helper'
+            //     which must become '../common/helpers/db.helper' after the flatten.
+            //   - src/core/common/interfaces/core-persistence-model.interface.ts
+            //     references '../../..' (three levels up to src/index.ts), which
+            //     must become '../..' (two levels up to src/core/index.ts).
+            const tsMorphProject = new Project({ skipAddingFilesFromTsConfig: true });
+            const flattenTargets = [`${coreDir}/index.ts`, `${coreDir}/core.module.ts`];
+            for (const target of flattenTargets) {
+                if (!filesystem.exists(target))
+                    continue;
+                const sourceFile = tsMorphProject.addSourceFileAtPath(target);
+                for (const decl of sourceFile.getImportDeclarations()) {
+                    const spec = decl.getModuleSpecifierValue();
+                    if (spec && spec.startsWith('./core/')) {
+                        decl.setModuleSpecifier(spec.replace(/^\.\/core\//, './'));
+                    }
+                }
+                for (const decl of sourceFile.getExportDeclarations()) {
+                    const spec = decl.getModuleSpecifierValue();
+                    if (spec && spec.startsWith('./core/')) {
+                        decl.setModuleSpecifier(spec.replace(/^\.\/core\//, './'));
+                    }
+                }
+                sourceFile.saveSync();
+            }
+            const testHelperPath = `${coreDir}/test/test.helper.ts`;
+            if (filesystem.exists(testHelperPath)) {
+                const sourceFile = tsMorphProject.addSourceFileAtPath(testHelperPath);
+                for (const decl of sourceFile.getImportDeclarations()) {
+                    const spec = decl.getModuleSpecifierValue();
+                    if (spec && spec.startsWith('../core/')) {
+                        decl.setModuleSpecifier(spec.replace(/^\.\.\/core\//, '../'));
+                    }
+                }
+                sourceFile.saveSync();
+            }
+            const persistenceIfacePath = `${coreDir}/common/interfaces/core-persistence-model.interface.ts`;
+            if (filesystem.exists(persistenceIfacePath)) {
+                const sourceFile = tsMorphProject.addSourceFileAtPath(persistenceIfacePath);
+                for (const decl of sourceFile.getImportDeclarations()) {
+                    const spec = decl.getModuleSpecifierValue();
+                    if (spec === '../../..') {
+                        decl.setModuleSpecifier('../..');
+                    }
+                }
+                sourceFile.saveSync();
+            }
+            // Edge: core-better-auth-user.mapper.ts uses `ScryptOptions` as a type
+            // annotation without an explicit import. Upstream relies on older
+            // @types/node versions where ScryptOptions was a global. With newer
+            // @types/node (25+) it must be imported from 'crypto'. Add the import.
+            const betterAuthMapperPath = `${coreDir}/modules/better-auth/core-better-auth-user.mapper.ts`;
+            if (filesystem.exists(betterAuthMapperPath)) {
+                const raw = filesystem.read(betterAuthMapperPath) || '';
+                if (raw.includes('ScryptOptions') && !raw.includes('type ScryptOptions')) {
+                    // Replace the bare `randomBytes, scrypt` crypto import with one
+                    // that also pulls in the ScryptOptions type.
+                    const patched = raw.replace(/import\s+\{\s*randomBytes\s*,\s*scrypt\s*\}\s+from\s+['"]crypto['"]\s*;/, "import { randomBytes, scrypt, type ScryptOptions } from 'crypto';");
+                    if (patched !== raw) {
+                        filesystem.write(betterAuthMapperPath, patched);
+                    }
+                }
+            }
+            // ── 4. Rewrite consumer imports: '@lenne.tech/nest-server' → relative ─
+            //
+            // Every .ts file in the starter's src/server/, src/main.ts, tests/,
+            // migrations/, scripts/, migrations-utils/ currently imports from
+            // '@lenne.tech/nest-server'. After vendoring, these must use a
+            // relative path to src/core whose depth depends on the file location.
+            // We handle static imports, dynamic imports, and CJS require() calls.
+            const codemodGlobs = [
+                `${dest}/src/server/**/*.ts`,
+                `${dest}/src/main.ts`,
+                `${dest}/src/config.env.ts`,
+                `${dest}/tests/**/*.ts`,
+                `${dest}/migrations/**/*.ts`,
+                `${dest}/migrations-utils/*.ts`,
+                `${dest}/scripts/**/*.ts`,
+            ];
+            tsMorphProject.addSourceFilesAtPaths(codemodGlobs);
+            for (const file of tsMorphProject.getSourceFiles()) {
+                const filePath = file.getFilePath();
+                // Skip files inside src/core/ — those are the framework itself.
+                if (filePath.startsWith(coreDir))
+                    continue;
+                const fromDir = path.dirname(filePath);
+                let relToCore = path.relative(fromDir, coreDir).split(path.sep).join('/');
+                if (!relToCore.startsWith('.')) {
+                    relToCore = `./${relToCore}`;
+                }
+                let touched = false;
+                // Static import declarations
+                for (const decl of file.getImportDeclarations()) {
+                    if (decl.getModuleSpecifierValue() === '@lenne.tech/nest-server') {
+                        decl.setModuleSpecifier(relToCore);
+                        touched = true;
+                    }
+                }
+                // Static export declarations (re-exports)
+                for (const decl of file.getExportDeclarations()) {
+                    if (decl.getModuleSpecifierValue() === '@lenne.tech/nest-server') {
+                        decl.setModuleSpecifier(relToCore);
+                        touched = true;
+                    }
+                }
+                // Dynamic imports + CJS require('@lenne.tech/nest-server')
+                file.forEachDescendant((node) => {
+                    if (node.getKind() !== SyntaxKind.CallExpression)
+                        return;
+                    const call = node;
+                    const expr = call.getExpression();
+                    const exprText = expr.getText();
+                    const args = call.getArguments();
+                    if (args.length === 0)
+                        return;
+                    const firstArg = args[0];
+                    if (firstArg.getKind() !== SyntaxKind.StringLiteral)
+                        return;
+                    if (firstArg.getLiteralText() !== '@lenne.tech/nest-server')
+                        return;
+                    if (exprText === 'require' || exprText === 'import' || expr.getKind() === SyntaxKind.ImportKeyword) {
+                        firstArg.replaceWithText(`'${relToCore}'`);
+                        touched = true;
+                    }
+                });
+                if (touched) {
+                    file.saveSync();
+                }
+            }
+            // Also patch migrations-utils/*.js (CJS require) via raw string replace
+            // because ts-morph doesn't load .js files in our Project instance.
+            const migrationsUtilsDir = `${dest}/migrations-utils`;
+            if (filesystem.exists(migrationsUtilsDir)) {
+                const jsFiles = filesystem.find(migrationsUtilsDir, { matching: '*.js', recursive: false });
+                for (const f of jsFiles || []) {
+                    try {
+                        const content = filesystem.read(f);
+                        if (content && content.includes('@lenne.tech/nest-server')) {
+                            // The migrate helper path is at core/modules/migrate/helpers/migration.helper
+                            // regardless of mode, so we replace the package root reference
+                            // with the relative path to the vendored core.
+                            const fromDir = path.dirname(f);
+                            let relToCore = path.relative(fromDir, coreDir).split(path.sep).join('/');
+                            if (!relToCore.startsWith('.')) {
+                                relToCore = `./${relToCore}`;
+                            }
+                            const patched = content
+                                .replace(/require\(['"]@lenne\.tech\/nest-server['"]\)/g, `require('${relToCore}')`)
+                                .replace(/require\(['"]@lenne\.tech\/nest-server\/dist\/([^'"]+)['"]\)/g, (_m, sub) => `require('${relToCore}/${sub}')`);
+                            if (patched !== content) {
+                                filesystem.write(f, patched);
+                            }
+                        }
+                    }
+                    catch (_c) {
+                        // skip unreadable file
+                    }
+                }
+            }
+            // Explicit rewrite of migrations-utils/migrate.js — the generic codemod
+            // above works indirectly (via `bin/migrate.js` loading ts-node first),
+            // but it's fragile: if somebody invokes migrate.js standalone, `require
+            // ('../src/core')` would crash because Node cannot load TypeScript.
+            // Replace the file with the explicit, imo-pilot-proven variant that
+            // registers ts-node itself BEFORE requiring the vendored core and
+            // points at the specific migration.helper path (not the index hub).
+            const migrateJsPath = `${dest}/migrations-utils/migrate.js`;
+            filesystem.write(migrateJsPath, [
+                '// The vendored core is TypeScript-only (no prebuilt dist/). Register ts-node (via our',
+                '// custom bootstrap) before requiring any vendor module, so that .ts source files are',
+                '// transparently compiled on demand. Uses the same compiler config as the migrate CLI.',
+                "require('./ts-compiler');",
+                '',
+                "const { createMigrationStore } = require('../src/core/modules/migrate/helpers/migration.helper');",
+                "const config = require('../src/config.env');",
+                '',
+                'module.exports = createMigrationStore(',
+                '  config.default.mongoose.uri,',
+                "  'migrations' // optional, default is 'migrations'",
+                ');',
+                '',
+            ].join('\n'));
+            // ── 4b. Copy vendor maintenance scripts ──────────────────────────────
+            //
+            // These scripts are consumed by the `nest-server-core-updater` and
+            // `nest-server-core-contributor` Claude Code agents and by the
+            // `check`/`check:fix`/`check:naf` pipelines below. They live at
+            // `scripts/vendor/` in every vendored project:
+            //
+            //   check-vendor-freshness.mjs — non-blocking warning that the
+            //     vendored core is behind the latest upstream release. Hooked
+            //     into `check` / `check:fix` / `check:naf`.
+            //
+            //   sync-from-upstream.ts — produces a structured diff (upstream
+            //     delta vs. baseline, local changes, conflict map) that the
+            //     updater agent parses when pulling a new upstream version.
+            //
+            //   propose-upstream-pr.ts — scans local commits that touched
+            //     src/core/ and emits per-commit patch files the contributor
+            //     agent uses to open upstream PRs.
+            //
+            // Templates live at `src/templates/vendor-scripts/` in the CLI and
+            // are copied into the new project's `scripts/vendor/`.
+            const vendorScriptsSrc = path.join(__dirname, '..', 'templates', 'vendor-scripts');
+            const vendorScriptsDest = `${dest}/scripts/vendor`;
+            if (filesystem.exists(vendorScriptsSrc)) {
+                if (!filesystem.exists(vendorScriptsDest)) {
+                    filesystem.dir(vendorScriptsDest);
+                }
+                const vendorScriptFiles = filesystem.find(vendorScriptsSrc, { matching: '*' });
+                for (const src of vendorScriptFiles || []) {
+                    const base = path.basename(src);
+                    filesystem.copy(src, `${vendorScriptsDest}/${base}`, { overwrite: true });
+                }
+            }
+            // ── 4c. .gitignore: ignore transient vendor script outputs ──────────
+            //
+            // sync-from-upstream.ts writes diffs to scripts/vendor/sync-results/
+            // and propose-upstream-pr.ts writes patches to
+            // scripts/vendor/upstream-candidates/. Both are throw-away analysis
+            // artifacts and must not be committed.
+            const gitignorePath = `${dest}/.gitignore`;
+            if (filesystem.exists(gitignorePath)) {
+                const raw = filesystem.read(gitignorePath) || '';
+                const entries = ['scripts/vendor/sync-results/', 'scripts/vendor/upstream-candidates/'];
+                const missing = entries.filter((e) => !raw.includes(e));
+                if (missing.length > 0) {
+                    const block = `\n# Vendor-sync / upstream-contribute output (transient analysis artifacts)\n${missing.join('\n')}\n`;
+                    filesystem.write(gitignorePath, raw.trimEnd() + block);
+                }
+            }
+            // ── 5. package.json: remove @lenne.tech/nest-server, add migrate/bin ─
+            //
+            // Delete the framework dep — it's no longer needed since src/core/
+            // carries the code inline. Leave the starter's other deps alone (they
+            // already cover everything `@lenne.tech/nest-server` pulled in
+            // transitively because the starter pins them via pnpm overrides / direct
+            // deps already; see nest-server-starter/package.json).
+            const pkgPath = `${dest}/package.json`;
+            if (filesystem.exists(pkgPath)) {
+                const pkg = filesystem.read(pkgPath, 'json');
+                if (pkg && typeof pkg === 'object') {
+                    if (pkg.dependencies && typeof pkg.dependencies === 'object') {
+                        delete pkg.dependencies['@lenne.tech/nest-server'];
+                    }
+                    if (pkg.devDependencies && typeof pkg.devDependencies === 'object') {
+                        delete pkg.devDependencies['@lenne.tech/nest-server'];
+                    }
+                    // Merge the framework's transitive deps into the project's own deps.
+                    // The starter lists a minimal subset (express, mongoose, class-validator,
+                    // etc.) and previously relied on @lenne.tech/nest-server to pull in
+                    // all the other framework dependencies (@apollo/server, @nestjs/jwt,
+                    // @nestjs/passport, bcrypt, better-auth, ejs, @tus/server, etc.) as
+                    // transitive deps. After vendoring we lose that automatic transitivity,
+                    // so we must add those deps explicitly to the project package.json.
+                    //
+                    // Fully dynamic: we pull in EVERY upstream dependency that the
+                    // project doesn't already have. No hard-coded package lists —
+                    // additions to upstream's package.json surface automatically on
+                    // the next vendor-init or vendor-sync.
+                    if (!pkg.dependencies)
+                        pkg.dependencies = {};
+                    const deps = pkg.dependencies;
+                    for (const [depName, depVersion] of Object.entries(upstreamDeps)) {
+                        if (depName === '@lenne.tech/nest-server')
+                            continue;
+                        if (!(depName in deps)) {
+                            deps[depName] = depVersion;
+                        }
+                    }
+                    // Merge upstream devDependencies that a consumer project actually
+                    // needs at compile time. Rather than hard-coding a list of types
+                    // packages (which would drift as upstream evolves), we accept any
+                    // `@types/*` package whose base package is present in the merged
+                    // runtime deps (e.g. if `bcrypt` is in deps, `@types/bcrypt` is
+                    // accepted). This scales to new upstream additions automatically.
+                    //
+                    // Additionally, any upstream devDependency that the CLI knows is
+                    // used at runtime by the framework (via the dedicated
+                    // `vendorRuntimeDevDeps` predicate below) is promoted into
+                    // `dependencies`, because after vendoring the framework code lives
+                    // in the project and needs its runtime helpers available in prod.
+                    if (!pkg.devDependencies)
+                        pkg.devDependencies = {};
+                    const devDeps = pkg.devDependencies;
+                    for (const [depName, depVersion] of Object.entries(upstreamDevDeps)) {
+                        // Runtime-needed devDeps → promote to dependencies
+                        if (this.isVendorRuntimeDep(depName) && !(depName in deps)) {
+                            deps[depName] = depVersion;
+                            continue;
+                        }
+                        // @types/<pkg> where <pkg> is a runtime dep → accept as devDep
+                        if (depName.startsWith('@types/')) {
+                            const basePkg = depName.slice('@types/'.length);
+                            const matchesRuntime = basePkg in deps ||
+                                basePkg === 'node' ||
+                                // scoped types: @types/foo__bar ↔ @foo/bar
+                                (basePkg.includes('__') && `@${basePkg.replace('__', '/')}` in deps);
+                            if (matchesRuntime && !(depName in devDeps) && !(depName in deps)) {
+                                devDeps[depName] = depVersion;
+                            }
+                        }
+                    }
+                    // Add a script to run the local bin/migrate.js. The starter's
+                    // existing migrate:* scripts are already correct for npm mode; we
+                    // need them pointing at the local bin + local ts-compiler.
+                    //
+                    // Also wire the vendor maintenance scripts (check-vendor-freshness,
+                    // vendor:sync, vendor:propose-upstream) and hook the freshness
+                    // check into `check` / `check:fix` / `check:naf` as a non-blocking
+                    // first step.
+                    if (pkg.scripts && typeof pkg.scripts === 'object') {
+                        const scripts = pkg.scripts;
+                        const migrateArgs = '--store ./migrations-utils/migrate.js --migrations-dir ./migrations --compiler ts:./migrations-utils/ts-compiler.js';
+                        scripts['migrate:create'] =
+                            `f() { node ./bin/migrate.js create "$1" --template-file ./src/core/modules/migrate/templates/migration-project.template.ts --migrations-dir ./migrations --compiler ts:./migrations-utils/ts-compiler.js; }; f`;
+                        scripts['migrate:up'] = `node ./bin/migrate.js up ${migrateArgs}`;
+                        scripts['migrate:down'] = `node ./bin/migrate.js down ${migrateArgs}`;
+                        scripts['migrate:list'] = `node ./bin/migrate.js list ${migrateArgs}`;
+                        scripts['migrate:develop:up'] = `NODE_ENV=develop node ./bin/migrate.js up ${migrateArgs}`;
+                        scripts['migrate:test:up'] = `NODE_ENV=test node ./bin/migrate.js up ${migrateArgs}`;
+                        scripts['migrate:preview:up'] = `NODE_ENV=preview node ./bin/migrate.js up ${migrateArgs}`;
+                        scripts['migrate:prod:up'] = `NODE_ENV=production node ./bin/migrate.js up ${migrateArgs}`;
+                        // Vendor maintenance scripts
+                        scripts['check:vendor-freshness'] = 'node scripts/vendor/check-vendor-freshness.mjs';
+                        scripts['vendor:sync'] = 'node -r ./migrations-utils/ts-compiler scripts/vendor/sync-from-upstream.ts';
+                        scripts['vendor:propose-upstream'] =
+                            'node -r ./migrations-utils/ts-compiler scripts/vendor/propose-upstream-pr.ts';
+                        // Hook vendor-freshness as the first step of check / check:fix /
+                        // check:naf. Non-blocking (exit 0 even on mismatch), so it just
+                        // surfaces the warning at the top of the log.
+                        const hookFreshness = (scriptName) => {
+                            const existing = scripts[scriptName];
+                            if (!existing)
+                                return;
+                            if (existing.includes('check:vendor-freshness'))
+                                return;
+                            // Inject the freshness check right after the initial `pnpm install`
+                            // or at the very beginning of the chain. Looks for a leading
+                            // `pnpm install && ` and inserts after it; otherwise prepends.
+                            const installPrefix = 'pnpm install && ';
+                            if (existing.startsWith(installPrefix)) {
+                                scripts[scriptName] = `${installPrefix}pnpm run check:vendor-freshness && ${existing.slice(installPrefix.length)}`;
+                            }
+                            else {
+                                scripts[scriptName] = `pnpm run check:vendor-freshness && ${existing}`;
+                            }
+                        };
+                        hookFreshness('check');
+                        hookFreshness('check:fix');
+                        hookFreshness('check:naf');
+                    }
+                    filesystem.write(pkgPath, pkg, { jsonIndent: 2 });
+                }
+            }
+            // ── 6. migrations-utils/ts-compiler.js bootstrap ─────────────────────
+            //
+            // The project's tsconfig.json restricts `types` to vitest/globals
+            // which hides Node globals (__dirname, require, exports). This
+            // bootstrap registers ts-node with an explicit Node-aware config.
+            // Always write it fresh in vendor mode — overwrites whatever the
+            // starter shipped (which relies on node_modules/@lenne.tech/nest-server).
+            const tsCompilerPath = `${dest}/migrations-utils/ts-compiler.js`;
+            filesystem.write(tsCompilerPath, [
+                '/**',
+                ' * ts-node bootstrap for the migrate CLI (vendor mode).',
+                ' *',
+                " * The project's tsconfig.json restricts `types` to vitest/globals",
+                ' * which hides Node globals (__dirname, require, exports). This',
+                ' * bootstrap registers ts-node with an explicit Node-aware config.',
+                ' */',
+                "const tsNode = require('ts-node');",
+                '',
+                'tsNode.register({',
+                '  transpileOnly: true,',
+                '  compilerOptions: {',
+                "    module: 'commonjs',",
+                "    target: 'es2022',",
+                '    esModuleInterop: true,',
+                '    experimentalDecorators: true,',
+                '    emitDecoratorMetadata: true,',
+                '    skipLibCheck: true,',
+                "    types: ['node'],",
+                '  },',
+                '});',
+                '',
+            ].join('\n'));
+            // ── 6b. extras/sync-packages.mjs: replace with vendor-aware stub ─────
+            //
+            // The starter's `extras/sync-packages.mjs` pulls the latest deps of
+            // `@lenne.tech/nest-server` from the npm registry and merges them into
+            // the project's package.json. In vendor mode the framework is no
+            // longer an npm dependency, so the script has nothing meaningful to
+            // sync and would either no-op or error out.
+            //
+            // Replace it with a small informational stub that points the user at
+            // the canonical vendor-update path (the `nest-server-core-updater`
+            // Claude Code agent / `pnpm run vendor:sync` if the project has that
+            // script). Keeps `pnpm run update` from dead-exiting with a confusing
+            // message.
+            const syncPackagesPath = `${dest}/extras/sync-packages.mjs`;
+            if (filesystem.exists(syncPackagesPath)) {
+                filesystem.write(syncPackagesPath, [
+                    '#!/usr/bin/env node',
+                    '',
+                    "'use strict';",
+                    '',
+                    '/**',
+                    ' * Vendor-mode stub for extras/sync-packages.mjs.',
+                    ' *',
+                    ' * The original script is designed for npm-mode projects where',
+                    " * `@lenne.tech/nest-server` is an installed dependency and",
+                    ' * `pnpm run update` pulls the latest upstream deps into the',
+                    ' * project package.json.',
+                    ' *',
+                    ' * This project runs in VENDOR mode: the framework core/ tree is',
+                    ' * copied directly into src/core/ and there is no framework npm',
+                    ' * dep to sync. To update the vendored core, use the',
+                    ' * `nest-server-core-updater` Claude Code agent or run the',
+                    ' * project-local vendor:sync script once it has been added.',
+                    ' */',
+                    '',
+                    "console.warn('');",
+                    "console.warn('⚠  pnpm run update is a no-op in vendor mode.');",
+                    "console.warn('   Framework source lives directly in src/core/ and is updated');",
+                    "console.warn('   via the nest-server-core-updater agent:');",
+                    "console.warn('');",
+                    "console.warn('     /lt-dev:backend:update-nest-server-core');",
+                    "console.warn('');",
+                    "console.warn('   See src/core/VENDOR.md for the current baseline and sync history.');",
+                    "console.warn('');",
+                    'process.exit(0);',
+                    '',
+                ].join('\n'));
+            }
+            // ── 7. tsconfig.json excludes + Node types ───────────────────────────
+            //
+            // The vendored migrate template references `from '@lenne.tech/nest-server'`
+            // as a placeholder that only makes sense in the *generated* migration
+            // file's context. Exclude it from compilation.
+            //
+            // The starter's tsconfig.json restricts `types` to `['vitest/globals']`
+            // because the shipped framework dist was pre-compiled with Node types
+            // baked in. In vendor mode we compile the framework source directly,
+            // so we MUST also load `@types/node` — otherwise types like
+            // `ScryptOptions` in core-better-auth-user.mapper.ts break the build.
+            this.widenTsconfigExcludes(`${dest}/tsconfig.json`);
+            this.widenTsconfigExcludes(`${dest}/tsconfig.build.json`);
+            this.widenTsconfigTypes(`${dest}/tsconfig.json`);
+            this.widenTsconfigTypes(`${dest}/tsconfig.build.json`);
+            // ── 9b. Prepend a vendor-mode block to projects/api/CLAUDE.md ────────
+            //
+            // Claude Code's project-level CLAUDE.md is the single source of truth
+            // for "what kind of project is this". Prepending a short vendor block
+            // tells any downstream agent (backend-dev, generating-nest-servers,
+            // nest-server-updater, …) that the framework lives at src/core/ and
+            // that generated imports must use relative paths, before they even
+            // read the rest of the file.
+            const apiClaudeMdPath = `${dest}/CLAUDE.md`;
+            if (filesystem.exists(apiClaudeMdPath)) {
+                const existing = filesystem.read(apiClaudeMdPath) || '';
+                const marker = '<!-- lt-vendor-marker -->';
+                if (!existing.includes(marker)) {
+                    const vendorBlock = [
+                        marker,
+                        '',
+                        '# Vendor-Mode Notice',
+                        '',
+                        'This api project runs in **vendor mode**: the `@lenne.tech/nest-server`',
+                        'core/ tree has been copied directly into `src/core/` as first-class',
+                        'project code. There is **no** `@lenne.tech/nest-server` npm dependency.',
+                        '',
+                        '- **Read framework code from `src/core/**`** — not from `node_modules/`.',
+                        '- **Generated imports use relative paths** to `src/core`, e.g.',
+                        '  `import { CrudService } from \'../../../core\';`',
+                        '  The exact depth depends on the file location. `lt server module`',
+                        '  computes it automatically.',
+                        '- **Baseline + patch log** live in `src/core/VENDOR.md`. Log any',
+                        '  substantial local change there so the `nest-server-core-updater`',
+                        '  agent can classify it at sync time.',
+                        '- **Update flow:** run `/lt-dev:backend:update-nest-server-core` (the',
+                        '  agent clones upstream, computes a delta, and presents a review).',
+                        '- **Contribute back:** run `/lt-dev:backend:contribute-nest-server-core`',
+                        '  to propose local fixes as upstream PRs.',
+                        '- **Freshness check:** `pnpm run check:vendor-freshness` warns (non-',
+                        '  blockingly) when upstream has a newer release than the baseline.',
+                        '',
+                        '---',
+                        '',
+                    ].join('\n');
+                    filesystem.write(apiClaudeMdPath, vendorBlock + existing);
+                }
+            }
+            // ── 10. VENDOR.md baseline ───────────────────────────────────────────
+            //
+            // Record the exact upstream version + commit SHA we vendored from, so
+            // the `nest-server-core-updater` agent has a reliable base for
+            // computing upstream deltas on the next sync.
+            const vendorMdPath = `${dest}/src/core/VENDOR.md`;
+            if (!filesystem.exists(vendorMdPath)) {
+                const today = new Date().toISOString().slice(0, 10);
+                const versionLine = upstreamVersion
+                    ? `- **Baseline-Version:** ${upstreamVersion}`
+                    : '- **Baseline-Version:** (not detected — run `vendor:sync` to record)';
+                const commitLine = upstreamCommit
+                    ? `- **Baseline-Commit:** \`${upstreamCommit}\``
+                    : '- **Baseline-Commit:** (not detected)';
+                const syncHistoryTo = upstreamVersion
+                    ? `${upstreamVersion}${upstreamCommit ? ` (\`${upstreamCommit.slice(0, 10)}\`)` : ''}`
+                    : 'initial import';
+                filesystem.write(vendorMdPath, [
+                    '# @lenne.tech/nest-server – core (vendored)',
+                    '',
+                    'This directory is a curated vendor copy of the `core/` tree from',
+                    '@lenne.tech/nest-server. It is first-class project code, not a',
+                    'node_modules shadow copy. Edit freely; log substantial changes in',
+                    'the "Local changes" table below so the `nest-server-core-updater`',
+                    'agent can classify them at sync time.',
+                    '',
+                    'The flatten-fix was applied during `lt fullstack init`: the',
+                    'upstream `src/index.ts`, `src/core.module.ts`, `src/test/`,',
+                    '`src/templates/`, `src/types/`, and `LICENSE` were moved under',
+                    '`src/core/` and their relative `./core/…` specifiers were',
+                    'stripped. See the init code in',
+                    '`lenneTech/cli/src/extensions/server.ts#convertCloneToVendored`.',
+                    '',
+                    '## Baseline',
+                    '',
+                    '- **Upstream-Repo:** https://github.com/lenneTech/nest-server',
+                    versionLine,
+                    commitLine,
+                    `- **Vendored am:** ${today}`,
+                    `- **Vendored von:** lt CLI (\`lt fullstack init --framework-mode vendor\`)`,
+                    '',
+                    '## Sync history',
+                    '',
+                    '| Date | From | To | Notes |',
+                    '| ---- | ---- | -- | ----- |',
+                    `| ${today} | — | ${syncHistoryTo} | scaffolded by lt CLI |`,
+                    '',
+                    '## Local changes',
+                    '',
+                    '| Date | Commit | Scope | Reason | Status |',
+                    '| ---- | ------ | ----- | ------ | ------ |',
+                    '| — | — | (none, pristine) | initial vendor | — |',
+                    '',
+                    '## Upstream PRs',
+                    '',
+                    '| PR | Title | Commits | Status |',
+                    '| -- | ----- | ------- | ------ |',
+                    '| — | (none yet) | — | — |',
+                    '',
+                ].join('\n'));
+            }
+            return { upstreamDeps, upstreamDevDeps };
+        });
+    }
+    /**
+     * Predicate: is a given upstream `devDependencies` key actually a runtime
+     * dep in disguise that needs to live in `dependencies` after vendoring?
+     *
+     * `@lenne.tech/nest-server` keeps a few packages in devDependencies that
+     * the framework code imports at runtime (e.g. `find-file-up` in its
+     * config loader). When we vendor the framework source into a consumer
+     * project, those must end up in `dependencies` so the compiled/dist
+     * runtime has them available.
+     *
+     * The list of such helpers lives in `src/config/vendor-runtime-deps.json`
+     * under the `runtimeHelpers` key. Adding a new helper is a data-only
+     * change (no CLI release required). If the config file is missing or
+     * unreadable, the predicate safely returns `false` for everything.
+     */
+    isVendorRuntimeDep(pkgName) {
+        if (!this._vendorRuntimeHelpers) {
+            try {
+                const path = require('path');
+                const configPath = path.join(__dirname, '..', 'config', 'vendor-runtime-deps.json');
+                const raw = this.filesystem.read(configPath, 'json');
+                const list = Array.isArray(raw === null || raw === void 0 ? void 0 : raw.runtimeHelpers) ? raw.runtimeHelpers : [];
+                this._vendorRuntimeHelpers = new Set(list.filter((e) => typeof e === 'string'));
+            }
+            catch (_a) {
+                this._vendorRuntimeHelpers = new Set();
+            }
+        }
+        return this._vendorRuntimeHelpers.has(pkgName);
+    }
+    /**
+     * Reads the GraphQL-only package list from the starter's
+     * `api-mode.manifest.json`. Must be called BEFORE `processApiMode`
+     * runs, because `processApiMode` deletes the manifest at the end of
+     * its REST-mode pass.
+     *
+     * Returns a flat list of package names that the manifest declares as
+     * GraphQL-specific (both `packages` and `devPackages` arrays from the
+     * `graphql` mode config). Empty list if the manifest is missing or
+     * malformed.
+     */
+    readApiModeGraphqlEssentials(dest) {
+        var _a;
+        const manifestPath = `${dest}/api-mode.manifest.json`;
+        if (!this.filesystem.exists(manifestPath))
+            return [];
+        try {
+            const manifest = this.filesystem.read(manifestPath, 'json');
+            const gqlMode = (_a = manifest === null || manifest === void 0 ? void 0 : manifest.modes) === null || _a === void 0 ? void 0 : _a.graphql;
+            if (!gqlMode || typeof gqlMode !== 'object')
+                return [];
+            const packages = [];
+            if (Array.isArray(gqlMode.packages))
+                packages.push(...gqlMode.packages);
+            if (Array.isArray(gqlMode.devPackages))
+                packages.push(...gqlMode.devPackages);
+            return packages.filter((p) => typeof p === 'string' && p.length > 0);
+        }
+        catch (_b) {
+            return [];
+        }
+    }
+    /**
+     * Restores framework-core-essential dependencies that the
+     * `api-mode.manifest.json` of the starter strips when running in
+     * REST-only mode. The vendored framework core at `src/core/` always
+     * imports these packages (e.g. `core-auth.module.ts` imports
+     * `graphql-subscriptions`), so even a pure REST project needs them
+     * available at compile time.
+     *
+     * The essentials list is captured BEFORE `processApiMode` runs (via
+     * `readApiModeGraphqlEssentials`) and passed in here. Versions come
+     * from the upstream `@lenne.tech/nest-server` package.json snapshot
+     * (passed in via `upstreamDeps`). No hard-coded package lists or
+     * versions — drift between starter and upstream is handled automatically
+     * at the next init.
+     */
+    restoreVendorCoreEssentials(options) {
+        var _a;
+        const { dest, essentials, upstreamDeps = {} } = options;
+        if (!essentials || essentials.length === 0)
+            return;
+        const pkgPath = `${dest}/package.json`;
+        if (!this.filesystem.exists(pkgPath))
+            return;
+        const pkg = this.filesystem.read(pkgPath, 'json');
+        if (!pkg || typeof pkg !== 'object')
+            return;
+        if (!pkg.dependencies)
+            pkg.dependencies = {};
+        const deps = pkg.dependencies;
+        for (const name of essentials) {
+            if (deps[name])
+                continue;
+            // Prefer the upstream-pinned version when available, else leave
+            // unversioned (`latest`) — install will resolve either way.
+            const version = (_a = upstreamDeps[name]) !== null && _a !== void 0 ? _a : 'latest';
+            deps[name] = version;
+        }
+        this.filesystem.write(pkgPath, pkg, { jsonIndent: 2 });
+    }
+    /**
+     * Ensures the given tsconfig contains both `node` and `vitest/globals`
+     * in its `types` array.
+     *
+     * - `node` is required because the vendored framework source uses Node
+     *   globals / types like `ScryptOptions` (from `node:crypto`), which
+     *   the starter's compiled dist never needed.
+     * - `vitest/globals` is required because `src/core/test/test.helper.ts`
+     *   uses the global `expect` from vitest, and that file is transitively
+     *   pulled into the build via TestHelper consumers. tsconfig `exclude`
+     *   doesn't help because exclude is a non-transitive filter.
+     *
+     * Idempotent. Handles both bracketed arrays and absent keys, and
+     * leaves the file untouched if both types are already listed.
+     */
+    widenTsconfigTypes(tsconfigPath) {
+        if (!this.filesystem.exists(tsconfigPath))
+            return;
+        try {
+            let raw = this.filesystem.read(tsconfigPath) || '';
+            const needed = ['node', 'vitest/globals'];
+            for (const type of needed) {
+                // Already contains this type in some types array — skip it.
+                const alreadyRegex = new RegExp(`"types"\\s*:\\s*\\[[^\\]]*"${type.replace(/\//g, '\\/')}"`);
+                if (alreadyRegex.test(raw))
+                    continue;
+                const typesRegex = /("types"\s*:\s*\[)([^\]]*)(\])/;
+                if (typesRegex.test(raw)) {
+                    raw = raw.replace(typesRegex, (_m, head, body, tail) => {
+                        const trimmed = body.trim();
+                        const joiner = trimmed.length > 0 ? ', ' : '';
+                        return `${head}${body}${joiner}"${type}"${tail}`;
+                    });
+                }
+                else {
+                    const compilerOptionsRegex = /("compilerOptions"\s*:\s*\{)/;
+                    if (compilerOptionsRegex.test(raw)) {
+                        raw = raw.replace(compilerOptionsRegex, `$1\n    "types": ["${type}"],`);
+                    }
+                }
+            }
+            this.filesystem.write(tsconfigPath, raw);
+        }
+        catch (_a) {
+            // best-effort
+        }
+    }
+    /**
+     * Adds the vendored migrate template file AND the vendored `src/core/test/`
+     * directory to the `exclude` array of a tsconfig (build or base).
+     *
+     * - The migrate template file is a text template that references
+     *   `@lenne.tech/nest-server` as a placeholder — only meaningful in the
+     *   *generated* migration file's context. Exclude from compilation.
+     * - `src/core/test/` contains `TestHelper`, which uses vitest globals
+     *   (`expect`, etc.) and is not intended for production dist. The
+     *   starter's `tsconfig.build.json` overrides `types` to `["node"]`,
+     *   which strips vitest globals; compiling `test.helper.ts` there
+     *   breaks. Exclude the whole `src/core/test/` subtree from the build.
+     *
+     * Handles both arrays with pre-existing entries and absent `exclude`
+     * keys. Idempotent.
+     */
+    widenTsconfigExcludes(tsconfigPath) {
+        if (!this.filesystem.exists(tsconfigPath)) {
+            return;
+        }
+        const EXCLUDE_ENTRIES = [
+            'src/core/modules/migrate/templates/**/*.template.ts',
+            'src/core/test/**/*.ts',
+        ];
+        try {
+            // The upstream tsconfig files may contain comments — standard JSON parse
+            // breaks on them. Use a regex-based patch as a fallback.
+            let raw = this.filesystem.read(tsconfigPath) || '';
+            for (const entry of EXCLUDE_ENTRIES) {
+                if (raw.includes(entry))
+                    continue;
+                const excludeRegex = /("exclude"\s*:\s*\[)([^\]]*)(\])/;
+                if (excludeRegex.test(raw)) {
+                    raw = raw.replace(excludeRegex, (_match, head, body, tail) => {
+                        const trimmed = body.trim();
+                        const joiner = trimmed.length > 0 ? ', ' : '';
+                        return `${head}${body}${joiner}"${entry}"${tail}`;
+                    });
+                }
+                else {
+                    // No exclude key at all — add one before the closing brace.
+                    const lastBrace = raw.lastIndexOf('}');
+                    if (lastBrace === -1)
+                        continue;
+                    const before = raw.slice(0, lastBrace);
+                    const after = raw.slice(lastBrace);
+                    const separator = before.trimEnd().endsWith(',') || before.trimEnd().endsWith('{') ? '' : ',';
+                    raw = `${before.trimEnd()}${separator}\n  "exclude": ["${entry}"]\n${after}`;
+                }
+            }
+            this.filesystem.write(tsconfigPath, raw);
+        }
+        catch (_a) {
+            // Best-effort; the project will still work, it just may need a
+            // manual `tsconfig.json` exclude when building.
+        }
+    }
     /**
      * Patch config.env.ts using TypeScript AST manipulation
      * - Replace SECRET_OR_PRIVATE_KEY placeholders with random secrets
@@ -768,6 +1830,34 @@ class Server {
             this.filesystem.write(configPath, content);
         }
     }
+    /**
+     * Patch CLAUDE.md with API mode information
+     * Replaces the generic "API Mode" line with the selected mode and removes the
+     * API Mode System section when not in "Both" mode (markers already stripped).
+     * @param dest - Target directory containing the CLAUDE.md file
+     * @param apiMode - Selected API mode (Rest, GraphQL, or Both)
+     */
+    patchClaudeMdApiMode(dest, apiMode) {
+        const claudeMdPath = `${dest}/CLAUDE.md`;
+        if (!this.filesystem.exists(claudeMdPath) || !apiMode) {
+            return;
+        }
+        let content = this.filesystem.read(claudeMdPath);
+        if (!content) {
+            return;
+        }
+        // Replace generic API mode placeholder or description
+        content = content.replace(/- \*\*API Mode:\*\* REST \(default\) or GraphQL or Both/, `- **API Mode:** ${apiMode}`);
+        // When not in "Both" mode, the region markers have been stripped by processApiMode.
+        // Replace the API Mode System section with a short note.
+        // Lookahead anchors (## Tooling, ## Framework:) match the known next-section headers in the
+        // nest-server-starter CLAUDE.md template. The $ fallback ensures the regex terminates even if
+        // neither header exists (e.g., template was customized).
+        if (apiMode !== 'Both') {
+            content = content.replace(/## API Mode System[\s\S]*?(?=## Tooling|## Framework:|$)/, `## API Mode\n\nThis project uses **${apiMode}** mode (configured during \`lt fullstack init\` / \`lt server create\`).\n\n`);
+        }
+        this.filesystem.write(claudeMdPath, content);
+    }
     /**
      * Replace secret or private keys in string (e.g. for config files)
      */
@@ -800,4 +1890,3 @@ exports.Server = Server;
 exports.default = (toolbox) => {
     toolbox.server = new Server(toolbox);
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/extensions/server.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,iCAAiC;AAIjC,+BAA4B;AAC5B,iCAAiC;AAajC;;GAEG;AACH,MAAa,MAAM;IA8FjB;;OAEG;IACH,YAAsB,OAA+B;QAA/B,YAAO,GAAP,OAAO,CAAwB;QArFrD,uCAAuC;QACvC,YAAO,GAA2B;YAChC,YAAY,EAAE,yDAAyD;YACvE,UAAU,EAAE,qEAAqE;YACjF,aAAa,EAAE,mEAAmE;YAClF,yBAAyB,EAAE,iDAAiD;SAC7E,CAAC;QAEF,gDAAgD;QAChD,oBAAe,GAA2B;YACxC,OAAO,EAAE,SAAS;YAClB,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,eAAe;YACrB,QAAQ,EAAE,eAAe;YACzB,EAAE,EAAE,QAAQ;YACZ,EAAE,EAAE,QAAQ;YACZ,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,MAAM;YACZ,MAAM,EAAE,QAAQ;YAChB,QAAQ,EAAE,QAAQ;YAClB,MAAM,EAAE,QAAQ;YAChB,MAAM,EAAE,eAAe;SACxB,CAAC;QAEF,iDAAiD;QACjD,oBAAe,GAA2B;YACxC,OAAO,EAAE,SAAS;YAClB,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,YAAY;YAClB,QAAQ,EAAE,YAAY;YACtB,EAAE,EAAE,QAAQ;YACZ,EAAE,EAAE,QAAQ;YACZ,IAAI,EAAE,yBAAyB;YAC/B,IAAI,EAAE,yBAAyB;YAC/B,MAAM,EAAE,QAAQ;YAChB,QAAQ,EAAE,QAAQ;YAClB,MAAM,EAAE,QAAQ;YAChB,MAAM,EAAE,YAAY;SACrB,CAAC;QAEF,gDAAgD;QAChD,oBAAe,GAA2B;YACxC,OAAO,EAAE,SAAS;YAClB,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,cAAc;YACpB,QAAQ,EAAE,cAAc;YACxB,EAAE,EAAE,QAAQ;YACZ,EAAE,EAAE,QAAQ;YACZ,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,MAAM;YACZ,MAAM,EAAE,QAAQ;YAChB,QAAQ,EAAE,QAAQ;YAClB,MAAM,EAAE,QAAQ;YAChB,MAAM,EAAE,cAAc;SACvB,CAAC;QAEF,+CAA+C;QAC/C,oBAAe,GAA2B;YACxC,OAAO,EAAE,SAAS;YAClB,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,cAAc;YACpB,QAAQ,EAAE,cAAc;YACxB,EAAE,EAAE,QAAQ;YACZ,EAAE,EAAE,QAAQ;YACZ,IAAI,EAAE,yBAAyB;YAC/B,IAAI,EAAE,yBAAyB;YAC/B,MAAM,EAAE,QAAQ;YAChB,QAAQ,EAAE,QAAQ;YAClB,MAAM,EAAE,QAAQ;YAChB,MAAM,EAAE,cAAc;SACvB,CAAC;QAEF,sCAAsC;QACtC,wBAAmB,GAA2B;YAC5C,EAAE,EAAE,IAAI;YACR,EAAE,EAAE,IAAI;YACR,QAAQ,EAAE,IAAI;SACf,CAAC;QAEF,4DAA4D;QAC5D,kBAAa,GAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAMhE,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;QAC9B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;QAC3C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;QACtC,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QACrC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;QAC3C,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;QAC7C,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;IACjC,CAAC;IAED;;OAEG;IACG,aAAa,CAAC,OAGnB;;YAOC,MAAM,EAAE,YAAY,EAAE,eAAe,EAAE,mBAAK,YAAY,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,IAAK,OAAO,CAAE,CAAC;YAEhG,YAAY;YACZ,MAAM,KAAK,GAAgC,EAAE,CAAC;YAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC;YACtB,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,IAAI,SAAS,GAAG,KAAK,CAAC;YACtB,OAAO,QAAQ,EAAE,CAAC;gBAChB,MAAM,IAAI,GAAG,CACX,MAAM,IAAI,CAAC,GAAG,CAAC;oBACb,OAAO,EAAE,8EAA8E;oBACvF,IAAI,EAAE,OAAO;oBACb,IAAI,EAAE,OAAO;iBACd,CAAC,CACH,CAAC,KAAK,CAAC;gBACR,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;oBACjB,MAAM;gBACR,CAAC;gBAED,IAAI,IAAI,GAAG,CACT,MAAM,IAAI,CAAC,GAAG,CAAC;oBACb;wBACE,OAAO,EAAE;4BACP,SAAS;4BACT,QAAQ;4BACR,QAAQ;4BACR,sBAAsB;4BACtB,MAAM;4BACN,MAAM;4BACN,WAAW;4BACX,SAAS;4BACT,YAAY;yBACb;wBACD,OAAO,EAAE,sBAAsB;wBAC/B,IAAI,EAAE,OAAO;wBACb,IAAI,EAAE,QAAQ;qBACf;iBACF,CAAC,CACH,CAAC,KAAK,CAAC;gBACR,IAAI,IAAI,KAAK,sBAAsB,EAAE,CAAC;oBACpC,IAAI,GAAG,UAAU,CAAC;gBACpB,CAAC;qBAAM,IAAI,IAAI,KAAK,YAAY,EAAE,CAAC;oBACjC,IAAI,GAAG,MAAM,CAAC;gBAChB,CAAC;gBAED,IAAI,MAAc,CAAC;gBACnB,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;oBACzB,IAAI,GAAG,CACL,MAAM,IAAI,CAAC,GAAG,CAAC;wBACb,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;wBAC9B,OAAO,EAAE,oCAAoC;wBAC7C,IAAI,EAAE,OAAO;wBACb,IAAI,EAAE,OAAO;qBACd,CAAC,CACH,CAAC,KAAK,CAAC;oBACR,MAAM,GAAG,IAAI,CAAC;oBACd,SAAS,GAAG,IAAI,CAAC;oBACjB,IAAI,IAAI,EAAE,CAAC;wBACT,OAAO,GAAG,IAAI,CAAC;oBACjB,CAAC;oBAED,IAAI,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI,EAAE,EAAE,CAAC;wBACjB,IAAI,cAAc,GAAY,KAAK,CAAC;wBACpC,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;wBAClC,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;wBACnD,MAAM,UAAU,GAAG,IAAA,WAAI,EAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;wBAC1F,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;4BACxC,cAAc,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,oDAAoD,EAAE,IAAI,CAAC,CAAC;wBAClG,CAAC;wBAED,IAAI,cAAc,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,KAAK,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;4BACvF,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;wBACtE,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,IAAI,SAAiB,CAAC;gBACtB,IAAI,OAAe,CAAC;gBACpB,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;oBACxB,SAAS,GAAG,CACV,MAAM,IAAI,CAAC,GAAG,CAAC;wBACb,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;wBAC9B,OAAO,EAAE,8BAA8B;wBACvC,IAAI,EAAE,OAAO;wBACb,IAAI,EAAE,OAAO;qBACd,CAAC,CACH,CAAC,KAAK,CAAC;oBACR,IAAI,SAAS,EAAE,CAAC;wBACd,OAAO,GAAG,IAAI,CAAC;oBACjB,CAAC;oBAED,IAAI,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,IAAI,EAAE,EAAE,CAAC;wBACtB,IAAI,cAAc,GAAY,KAAK,CAAC;wBACpC,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;wBAClC,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;wBACnD,MAAM,SAAS,GAAG,IAAA,WAAI,EAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;wBACpF,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;4BACvC,cAAc,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,oDAAoD,EAAE,IAAI,CAAC,CAAC;wBAClG,CAAC;wBAED,IAAI,cAAc,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC;4BAClG,eAAe,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;wBACjF,CAAC;oBACH,CAAC;gBACH,CAAC;qBAAM,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;oBAC3B,OAAO,GAAG,CACR,MAAM,IAAI,CAAC,GAAG,CAAC;wBACb,OAAO,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM;wBACvC,OAAO,EAAE,iBAAiB;wBAC1B,IAAI,EAAE,OAAO;wBACb,IAAI,EAAE,OAAO;qBACd,CAAC,CACH,CAAC,KAAK,CAAC;oBACR,IAAI,OAAO,EAAE,CAAC;wBACZ,OAAO,GAAG,IAAI,CAAC;oBACjB,CAAC;gBACH,CAAC;gBAED,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACxC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBAC9B,MAAM,OAAO,GAAG,WAAW,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAE9D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;gBAEvD,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;YAC9E,CAAC;YACD,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;QACtE,CAAC;KAAA;IAED,gCAAgC;;QAC9B,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QAC9D,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,UAAU,GAAG,EAAE,CAAC,cAAc,CAAC,YAAY,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACpE,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;gBACtB,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC;gBACnC,IAAI,MAAA,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,eAAe,0CAAE,uBAAuB,EAAE,CAAC;oBACvD,OAAO,QAAQ,CAAC,eAAe,CAAC,uBAAuB,CAAC;gBAC1D,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACH,iBAAiB,CAAC,IAAiB,EAAE,OAA8B;;QACjE,MAAM,EAAE,MAAM,EAAE,mBAAK,MAAM,EAAE,KAAK,IAAK,OAAO,CAAE,CAAC;QACjD,MAAM,SAAS,GAAG,CAAA,MAAA,IAAI,CAAC,SAAS,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACvF,MAAM,MAAM,GAAG,CAAA,MAAA,IAAI,CAAC,MAAM,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9E,MAAM,OAAO,GAAG,CAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAEjF,IAAI,MAAM,EAAE,CAAC;YACX,gDAAgD;YAChD,OAAO,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QACrD,CAAC;aAAM,IAAI,SAAS,EAAE,CAAC;YACrB,6CAA6C;YAC7C,OAAO,QAAQ,CAAC;QAClB,CAAC;aAAM,IAAI,OAAO,EAAE,CAAC;YACnB,uBAAuB;YACvB,OAAO,OAAO,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,iCAAiC;YACjC,IAAI,SAAS,GACX,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAChD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAClE,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC1F,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,IAAiB,EAAE,OAA8B;;QACjE,MAAM,EAAE,MAAM,EAAE,mBAAK,MAAM,EAAE,KAAK,IAAK,OAAO,CAAE,CAAC;QACjD,MAAM,SAAS,GAAG,CAAA,MAAA,IAAI,CAAC,SAAS,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACvF,MAAM,MAAM,GAAG,CAAA,MAAA,IAAI,CAAC,MAAM,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9E,MAAM,OAAO,GAAG,CAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAEjF,IAAI,MAAM,EAAE,CAAC;YACX,gDAAgD;YAChD,OAAO,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QACrD,CAAC;aAAM,IAAI,SAAS,EAAE,CAAC;YACrB,sCAAsC;YACtC,OAAO,QAAQ,CAAC;QAClB,CAAC;aAAM,IAAI,OAAO,EAAE,CAAC;YACnB,uBAAuB;YACvB,OAAO,OAAO,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,iCAAiC;YACjC,OAAO,CACL,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAChD,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;oBACrC,CAAC,CAAC,IAAI,CAAC,IAAI;oBACX,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CACrE,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,IAAiB;;QACjC,MAAM,SAAS,GAAG,CAAA,MAAA,IAAI,CAAC,SAAS,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACvF,MAAM,MAAM,GAAG,CAAA,MAAA,IAAI,CAAC,MAAM,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9E,MAAM,OAAO,GAAG,CAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAEjF,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,SAAS,CAAC;QACnB,CAAC;aAAM,IAAI,MAAM,EAAE,CAAC;YAClB,OAAO,MAAM,CAAC;QAChB,CAAC;aAAM,IAAI,OAAO,EAAE,CAAC;YACnB,OAAO,OAAO,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxF,CAAC;IACH,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,IAAiB;;QACjC,MAAM,SAAS,GAAG,CAAA,MAAA,IAAI,CAAC,SAAS,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACvF,MAAM,MAAM,GAAG,CAAA,MAAA,IAAI,CAAC,MAAM,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9E,MAAM,OAAO,GAAG,CAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAEjF,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,SAAS,CAAC;QACnB,CAAC;aAAM,IAAI,MAAM,EAAE,CAAC;YAClB,OAAO,MAAM,CAAC;QAChB,CAAC;aAAM,IAAI,OAAO,EAAE,CAAC;YACnB,OAAO,OAAO,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,OAAO,CACL,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAChD,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAClF,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,IAAiB;;QAC7B,MAAM,OAAO,GAAG,CAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACjF,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,IAAI,CAAC,OAAO;YACjB,CAAC,CAAC,iBAAiB,OAAO,oCAAoC;YAC9D,CAAC,CAAC,iBAAiB,OAAO,WAAW,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,SAAiB,EAAE,OAAgB;QAC/C,2CAA2C;QAC3C,OAAO,eAAe,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IAC9E,CAAC;IAED;;OAEG;IACH,aAAa,CACX,KAAkC,EAClC,OAAsD;;QAEtD,eAAe;QACf,MAAM,MAAM,mBAAK,UAAU,EAAE,IAAI,IAAK,OAAO,CAAE,CAAC;QAChD,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;QACzC,yGAAyG;QACzG,MAAM,eAAe,GAAG,IAAI,CAAC,gCAAgC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,eAAe,CAAC;QACxF,IAAI,MAAM,GAAG,EAAE,CAAC;QAEhB,mBAAmB;QACnB,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;YACzE,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;YACvD,CAAC;YAED,cAAc;YACd,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;gBAC7C,OAAO;oBACL,OAAO,EAAE,EAAE;oBACX,QAAQ,EAAE,wCAAwC;oBAClD,KAAK,EAAE;;;;;yDAKwC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;;kCAEjD,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;;;;;;wBAMpC,eAAe;;;+BAGR,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;;;4CAGb,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;;;;;;kBAMpD,eAAe;GAC9B;iBACM,CAAC;YACJ,CAAC;QACH,CAAC;QAED,wBAAwB;QACxB,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,MAAM,QAAQ,GAAG,EAAE,CAAC;QACpB,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAc,KAAK,CAAC,EAAE,CAAC;YAC9D,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACtC,MAAM,SAAS,GAAG,CAAA,MAAA,IAAI,CAAC,SAAS,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACvF,MAAM,MAAM,GAAG,CAAA,MAAA,IAAI,CAAC,MAAM,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9E,MAAM,OAAO,GAAG,CAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,IAAI,EAAE,EAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAEjF,2CAA2C;YAC3C,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YACpD,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YACpD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;YAE7B,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7F,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;gBACpG,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;YAC5B,CAAC;YACD,IAAI,SAAS,EAAE,CAAC;gBACd,QAAQ,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;YACjC,CAAC;YACD,IAAI,MAAM,EAAE,CAAC;gBACX,QAAQ,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;YAC9B,CAAC;YACD,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;gBACjC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACzD,CAAC;YAED,iDAAiD;YACjD,wDAAwD;YACxD,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAC5C,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;YAEjF,+BAA+B;YAC/B,MAAM,cAAc,GAAG,SAAS;gBAC9B,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,WAAW,SAAS,mCAAmC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBAClG,CAAC,CAAC,MAAM;oBACN,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,WAAW,MAAM,WAAW,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;oBACvE,CAAC,CAAC,OAAO;wBACP,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,WAAW,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,iBAAiB,OAAO,kBAAkB,CAAC,CAAC,CAAC,OAAO,mBAAmB,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;wBAC7I,CAAC,CAAC,IAAI,KAAK,MAAM;4BACf,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,mBAAmB,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;4BAC9D,CAAC,CAAC,MAAM,CAAC;YAEjB,MAAM,IAAI;;OAET,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;;;oBAGrE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;MAChG,UAAU,eAAe,IAAI,CAAC,QAAQ;gBAC5B,cAAc;iCAExB,UAAU;gBACR,CAAC,CAAC;MACJ,UAAU,EAAE;gBACV,CAAC,CAAC,EACN;;IAEA,QAAQ,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,IAAI,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,eAAe;GAC7H,CAAC;QACA,CAAC;QAED,kBAAkB;QAClB,IAAI,aAAa,GAAG,EAAE,CAAC;QACvB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3C,aAAa,IAAI,KAAK,KAAK,EAAE,CAAC;QAChC,CAAC;QAED,mBAAmB;QACnB,MAAM,cAAc,GAAG,EAAE,CAAC;QAC1B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YACpD,cAAc,CAAC,IAAI,CAAC,GAAG,GAAG,KAAK,KAAK,EAAE,CAAC,CAAC;QAC1C,CAAC;QAED,uBAAuB;QACvB,OAAO;YACL,OAAO,EAAE,aAAa;YACtB,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,uBAAuB,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO;YACxG,KAAK,EAAE,MAAM;SACd,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,aAAa,CACX,KAAkC,EAClC,OAAsE;QAEtE,eAAe;QACf,MAAM,MAAM,mBAAK,UAAU,EAAE,IAAI,IAAK,OAAO,CAAE,CAAC;QAChD,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;QAC3D,iGAAiG;QACjG,MAAM,eAAe,GAAG,IAAI,CAAC,gCAAgC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,eAAe,CAAC;QACxF,IAAI,MAAM,GAAG,EAAE,CAAC;QAEhB,mBAAmB;QACnB,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;YACzE,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;YACpC,CAAC;YAED,cAAc;YACd,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;gBAC7C,OAAO;oBACL,OAAO,EAAE,EAAE;oBACX,KAAK,EAAE;;;;;yDAKwC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,gBAC/E,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,SACtC;wBACsB,eAAe;;;+BAGR,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;;;4CAGb,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;kBACpD,MAAM,CAAC,QAAQ;;kBAEf,eAAe;GAC9B;iBACM,CAAC;YACJ,CAAC;YAED,wBAAwB;YACxB,MAAM,OAAO,GAAG,EAAE,CAAC;YACnB,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAc,KAAK,CAAC,EAAE,CAAC;gBAC9D,0EAA0E;gBAC1E,IAAI,MAAM,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAC5B,SAAS;gBACX,CAAC;gBAED,2CAA2C;gBAC3C,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;gBAChE,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;gBAChE,MAAM,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;gBAElF,oGAAoG;gBACpG,MAAM,cAAc,GAAG,IAAI,CAAC,gCAAgC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;gBAClF,MAAM,YAAY,GAAG,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;gBAClD,+CAA+C;gBAC/C,MAAM,uBAAuB,GAAG,YAAY,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC;gBAEjF,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;oBACjC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;gBACzD,CAAC;gBACD,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;oBACjC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;gBACzD,CAAC;gBAED,iDAAiD;gBACjD,wDAAwD;gBACxD,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;gBAC5C,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;gBAEtF,MAAM,IAAI;;OAEX,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,cAAc,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;;;oBAGlF,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,cAAc,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;MAC7G,UAAU,eAAe,QAAQ,IAAI,IAAI,CAAC,QAAQ;iCAElD,UAAU;oBACR,CAAC,CAAC;MACJ,UAAU,EAAE;oBACV,CAAC,CAAC,EACN;;IAEA,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,uBAAuB;GACnJ,CAAC;YACE,CAAC;YAED,kBAAkB;YAClB,IAAI,aAAa,GAAG,EAAE,CAAC;YACvB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC3C,aAAa,IAAI,KAAK,KAAK,EAAE,CAAC;YAChC,CAAC;YAED,uBAAuB;YACvB,OAAO;gBACL,OAAO,EAAE,aAAa;gBACtB,KAAK,EAAE,MAAM;aACd,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACG,WAAW,CACf,IAAY,EACZ,OAWC;;YAED,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;YAC5F,MAAM,EACJ,OAAO,EACP,MAAM,GAAG,EAAE,EACX,MAAM,EACN,QAAQ,EACR,WAAW,GAAG,EAAE,EAChB,QAAQ,EACR,IAAI,EACJ,UAAU,EACV,WAAW,GAAG,KAAK,EACnB,YAAY,GAAG,KAAK,GACrB,GAAG,OAAO,CAAC;YAEZ,iBAAiB;YACjB,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE;gBAC9C,MAAM;gBACN,QAAQ;gBACR,QAAQ;gBACR,OAAO,EAAE,sDAAsD;aAChE,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACpB,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YACtE,CAAC;YAED,sCAAsC;YACtC,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;gBAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YAC9D,CAAC;YAED,kEAAkE;YAClE,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,IAAI,CAAC;oBACH,kBAAkB;oBAClB,MAAM,QAAQ,CAAC,QAAQ,CAAC;wBACtB,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE;wBAC5B,MAAM,EAAE,GAAG,IAAI,YAAY;wBAC3B,QAAQ,EAAE,mCAAmC;qBAC9C,CAAC,CAAC;oBAEH,mEAAmE;oBACnE,IAAI,CAAC,gBAAgB,CAAC,GAAG,IAAI,oBAAoB,EAAE,UAAU,CAAC,CAAC;oBAE/D,0CAA0C;oBAC1C,MAAM,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,cAAc,EAAE,CAAC,OAAe,EAAE,EAAE,CAC/D,OAAO;yBACJ,OAAO,CAAC,qBAAqB,EAAE,cAAc,IAAI,IAAI,CAAC;yBACtD,OAAO,CAAC,2BAA2B,EAAE,oBAAoB,WAAW,IAAI,IAAI,IAAI,CAAC,CACrF,CAAC;oBAEF,sBAAsB;oBACtB,MAAM,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,eAAe,EAAE,CAAC,MAA+B,EAAE,EAAE;wBAChF,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;wBACvB,MAAM,CAAC,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;wBAC1B,MAAM,CAAC,WAAW,GAAG,WAAW,IAAI,IAAI,CAAC;wBACzC,MAAM,CAAC,QAAQ,GAAG,EAAE,CAAC;wBACrB,MAAM,CAAC,IAAI,GAAG,UAAU,CAAC;wBACzB,MAAM,CAAC,UAAU,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;wBAC7C,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;wBACzB,OAAO,MAAM,CAAC;oBAChB,CAAC,CAAC,CAAC;oBAEH,6BAA6B;oBAC7B,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,WAAW,CAAC,EAAE,CAAC;wBAC/C,MAAM,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,WAAW,EAAE,CAAC,MAA+B,EAAE,EAAE;4BAC5E,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;4BACnB,MAAM,CAAC,WAAW,GAAG,WAAW,CAAC;4BACjC,OAAO,MAAM,CAAC;wBAChB,CAAC,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;gBAC/D,CAAC;YACH,CAAC;YAED,uFAAuF;YACvF,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;gBAC7B,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,eAAe,CAAC,CAAC;gBAC/C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,oBAAoB,CAAC,CAAC;gBACpD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,iBAAiB,CAAC,CAAC;gBACjD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC;gBAC5C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,QAAQ,CAAC,CAAC;gBACxC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC;YAC9C,CAAC;YAED,+DAA+D;YAC/D,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,CAAC;oBACH,MAAM,aAAa,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;gBACpD,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;gBAC/D,CAAC;YACH,CAAC;YAED,mBAAmB;YACnB,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,IAAI,CAAC;oBACH,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;oBAC5B,MAAM,MAAM,CAAC,GAAG,CAAC,OAAO,IAAI,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;gBACrE,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;gBAC/D,CAAC;YACH,CAAC;YAED,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC9D,CAAC;KAAA;IAED;;;;;;OAMG;IACG,uBAAuB,CAC3B,IAAY,EACZ,OAOC;;YAED,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;YAChE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;YAE1E,iBAAiB;YACjB,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE;gBAC9C,MAAM;gBACN,QAAQ;gBACR,QAAQ;gBACR,OAAO,EAAE,kDAAkD;aAC5D,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACpB,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YACtE,CAAC;YAED,sCAAsC;YACtC,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;gBAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YAC9D,CAAC;YAED,sCAAsC;YACtC,IAAI,CAAC;gBACH,kBAAkB;gBAClB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,IAAI,gBAAgB,EAAE;oBAC7C,WAAW,EAAE,WAAW,IAAI,MAAM;oBAClC,IAAI,EAAE,GAAG,IAAI,aAAa;oBAC1B,OAAO,EAAE,OAAO;iBACjB,CAAC,CAAC;gBAEH,mEAAmE;gBACnE,IAAI,CAAC,gBAAgB,CAAC,GAAG,IAAI,oBAAoB,EAAE,UAAU,CAAC,CAAC;YACjE,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YAC/D,CAAC;YAED,qCAAqC;YACrC,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;gBAC7B,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,eAAe,CAAC,CAAC;gBAC/C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,oBAAoB,CAAC,CAAC;gBACpD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,iBAAiB,CAAC,CAAC;gBACjD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC;gBAC5C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,QAAQ,CAAC,CAAC;gBACxC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC;YAC9C,CAAC;YAED,oEAAoE;YACpE,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,CAAC;oBACH,MAAM,aAAa,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;gBACpD,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;gBAC/D,CAAC;YACH,CAAC;YAED,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC9D,CAAC;KAAA;IAED;;;;OAIG;IACH,gBAAgB,CAAC,UAAkB,EAAE,UAAkB;QACrD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;YACxC,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;YACpD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,EAAE,2BAA2B,EAAE,IAAI,EAAE,CAAC,CAAC;YACnE,MAAM,UAAU,GAAG,OAAO,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;YAE3D,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;YAE5C,KAAK,MAAM,OAAO,IAAI,UAAU,CAAC,oBAAoB,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC;gBAChF,MAAM,IAAI,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;gBAEtC,iEAAiE;gBACjE,IAAI,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,EAAE,CAAC;oBAC7C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;wBACzB,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;oBAClE,CAAC;oBACD,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,CAAC;oBAC9C,SAAS;gBACX,CAAC;gBAED,2DAA2D;gBAC3D,IAAI,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;oBAClC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,GAAG,UAAU,GAAG,CAAC,CAAC,CAAC;gBAC3E,CAAC;YACH,CAAC;YAED,UAAU,CAAC,QAAQ,EAAE,CAAC;QACxB,CAAC;QAAC,WAAM,CAAC;YACP,qDAAqD;YACrD,IAAI,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/C,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO;YACT,CAAC;YACD,OAAO,GAAG,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC,CAAC;YACnD,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,oBAAoB,EAAE,GAAG,UAAU,KAAK,CAAC,CAAC;YACpE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED;;OAEG;IACH,0BAA0B,CAAC,aAAqB;QAC9C,gGAAgG;QAChG,2EAA2E;QAC3E,MAAM,KAAK,GAAG,+BAA+B,CAAC;QAE9C,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAE3C,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrC,OAAO,aAAa,CAAC;QACvB,CAAC;QAED,mEAAmE;QACnE,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;QAE5C,OAAO,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;YAC5C,uCAAuC;YACvC,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAEvC,wEAAwE;YACxE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;gBAChC,SAAS,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;YACzE,CAAC;YAED,gCAAgC;YAChC,OAAO,IAAI,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC;QAC3C,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAp5BD,wBAo5BC;AAED;;GAEG;AACH,kBAAe,CAAC,OAA+B,EAAE,EAAE;IACjD,OAAO,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;AACvC,CAAC,CAAC"}