swallowkit 1.0.0-beta.6 → 1.0.0-beta.60

package/dist/cli/commands/init.js

@@ -36,12 +36,160 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStaticWebAppSku = getStaticWebAppSku;
+exports.buildCosmosDbFreeTierBicepSource = buildCosmosDbFreeTierBicepSource;
+exports.buildSharedTsConfig = buildSharedTsConfig;
 exports.initCommand = initCommand;
+exports.withNpmLockfileSafeManifests = withNpmLockfileSafeManifests;
+exports.parseIgnoredBuilds = parseIgnoredBuilds;
+exports.approveBuildsViaWorkspaceYaml = approveBuildsViaWorkspaceYaml;
+exports.injectSwallowKitNextConfig = injectSwallowKitNextConfig;
+exports.buildCSharpFunctionsProgramSource = buildCSharpFunctionsProgramSource;
+exports.buildCSharpFunctionsProjectSource = buildCSharpFunctionsProjectSource;
+exports.buildSwallowKitConfigSource = buildSwallowKitConfigSource;
+exports.buildGeneratedProjectDependencies = buildGeneratedProjectDependencies;
+exports.buildGeneratedProjectDevDependencies = buildGeneratedProjectDevDependencies;
+exports.buildSwallowKitMcpProjectConfigSource = buildSwallowKitMcpProjectConfigSource;
+exports.buildTypeScriptFunctionsPackageJson = buildTypeScriptFunctionsPackageJson;
+exports.buildFunctionsHostKeyBicepExpression = buildFunctionsHostKeyBicepExpression;
+exports.buildStaticWebAppConfigBicepSource = buildStaticWebAppConfigBicepSource;
+exports.createInfrastructure = createInfrastructure;
+exports.getGitHubFunctionsWorkflow = getGitHubFunctionsWorkflow;
+exports.getAzureFunctionsPipeline = getAzureFunctionsPipeline;
+exports.buildAzureSwaPipeline = buildAzureSwaPipeline;
+exports.buildGitHubSwaWorkflow = buildGitHubSwaWorkflow;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const prompts_1 = __importDefault(require("prompts"));
 const package_manager_1 = require("../../utils/package-manager");
+const manifest_1 = require("../../core/project/manifest");
+const workflows_1 = require("../../core/project/workflows");
+const agent_instructions_1 = require("../../core/project/agent-instructions");
+const native_schema_generator_1 = require("../../core/scaffold/native-schema-generator");
+const python_uv_1 = require("../../utils/python-uv");
+function getStaticWebAppSku(plan) {
+    return plan === 'free' ? 'Free' : 'Standard';
+}
+const BACKEND_LANGUAGE_CHOICES = [
+    { title: "TypeScript", value: "typescript" },
+    { title: "C#", value: "csharp" },
+    { title: "Python", value: "python" },
+];
+function usesNodeFunctionsProject(backendLanguage) {
+    return backendLanguage === "typescript";
+}
+function getBackendLanguageLabel(backendLanguage) {
+    return BACKEND_LANGUAGE_CHOICES.find((choice) => choice.value === backendLanguage)?.title || backendLanguage;
+}
+function buildCosmosDbFreeTierBicepSource() {
+    return `@description('Cosmos DB account name')
+param accountName string
+
+@description('Database name')
+param databaseName string
+
+@description('Location for Cosmos DB')
+param location string
+
+@description('Public network access')
+@allowed(['Enabled', 'Disabled'])
+param publicNetworkAccess string = 'Enabled'
+
+// Cosmos DB Account (Free Tier)
+resource cosmosAccount 'Microsoft.DocumentDB/databaseAccounts@2023-11-15' = {
+  name: accountName
+  location: location
+  kind: 'GlobalDocumentDB'
+  properties: {
+    databaseAccountOfferType: 'Standard'
+    enableAutomaticFailover: false
+    enableFreeTier: true
+    publicNetworkAccess: publicNetworkAccess
+    disableLocalAuth: true
+    consistencyPolicy: {
+      defaultConsistencyLevel: 'Session'
+    }
+    locations: [
+      {
+        locationName: location
+        failoverPriority: 0
+        isZoneRedundant: false
+      }
+    ]
+    disableKeyBasedMetadataWriteAccess: true
+  }
+}
+
+// Cosmos DB Database
+resource database 'Microsoft.DocumentDB/databaseAccounts/sqlDatabases@2023-11-15' = {
+  parent: cosmosAccount
+  name: databaseName
+  properties: {
+    resource: {
+      id: databaseName
+    }
+    options: {
+      throughput: 1000
+    }
+  }
+}
+
+output id string = cosmosAccount.id
+output accountName string = cosmosAccount.name
+output endpoint string = cosmosAccount.properties.documentEndpoint
+output databaseName string = database.name
+`;
+}
+function getFunctionsWorkerRuntime(backendLanguage) {
+    if (backendLanguage === "csharp") {
+        return "dotnet-isolated";
+    }
+    if (backendLanguage === "python") {
+        return "python";
+    }
+    return "node";
+}
+function getFunctionsRuntimeConfig(backendLanguage) {
+    if (backendLanguage === "csharp") {
+        return { name: "dotnet-isolated", version: "10.0" };
+    }
+    if (backendLanguage === "python") {
+        return { name: "python", version: "3.11" };
+    }
+    return { name: "node", version: "22" };
+}
+function buildSharedTsConfig() {
+    return {
+        compilerOptions: {
+            target: "ES2020",
+            module: "Node16",
+            moduleResolution: "node16",
+            lib: ["ES2020"],
+            outDir: "dist",
+            rootDir: ".",
+            declaration: true,
+            declarationMap: true,
+            sourceMap: true,
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+        },
+        include: ["index.ts", "models/**/*"],
+        exclude: ["node_modules", "dist"],
+    };
+}
+async function promptBackendLanguage() {
+    const response = await (0, prompts_1.default)({
+        type: "select",
+        name: "backendLanguage",
+        message: "Azure Functions backend language:",
+        choices: BACKEND_LANGUAGE_CHOICES,
+        initial: 0,
+    });
+    return response.backendLanguage || "typescript";
+}
 async function promptCiCd() {
     const response = await (0, prompts_1.default)({
         type: 'select',
@@ -56,40 +204,69 @@ async function promptCiCd() {
     });
     return response.cicd || 'skip';
 }
-async function promptAzureConfig() {
-    const cosmosResponse = await (0, prompts_1.default)({
-        type: 'select',
-        name: 'mode',
-        message: 'Cosmos DB mode (affects cost):',
-        choices: [
-            { title: 'Free Tier (1000 RU/s free, best for first project)', value: 'freetier' },
-            { title: 'Serverless (pay-per-use, flexible)', value: 'serverless' }
-        ],
-        initial: 0
-    });
-    const vnetResponse = await (0, prompts_1.default)({
-        type: 'select',
-        name: 'vnet',
-        message: 'Network security:',
-        choices: [
-            { title: 'VNet Integration (recommended) - Cosmos DB via Private Endpoint', value: 'outbound' },
-            { title: 'None - Public endpoints, simplest but least secure', value: 'none' }
-        ],
-        initial: 0
-    });
+async function promptAzureConfig(options) {
+    let swaPlan = options.swaPlan;
+    if (!swaPlan) {
+        const response = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'plan',
+            message: 'Azure Static Web Apps plan:',
+            choices: [
+                { title: 'Standard (production, SLA and advanced auth/networking features)', value: 'standard' },
+                { title: 'Free (personal projects, no SLA and lower quotas)', value: 'free' }
+            ],
+            initial: 0
+        });
+        swaPlan = response.plan || 'standard';
+    }
+    let cosmosDbMode = options.cosmosDbMode;
+    if (!cosmosDbMode) {
+        const response = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'mode',
+            message: 'Cosmos DB mode (affects cost):',
+            choices: [
+                { title: 'Free Tier (1000 RU/s free, best for first project)', value: 'freetier' },
+                { title: 'Serverless (pay-per-use, flexible)', value: 'serverless' }
+            ],
+            initial: 0
+        });
+        cosmosDbMode = response.mode || 'freetier';
+    }
+    let vnetOption = options.vnet;
+    if (!vnetOption) {
+        const response = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'vnet',
+            message: 'Network security:',
+            choices: [
+                { title: 'VNet Integration (recommended) - Cosmos DB via Private Endpoint', value: 'outbound' },
+                { title: 'None - Public endpoints, simplest but least secure', value: 'none' }
+            ],
+            initial: 0
+        });
+        vnetOption = response.vnet || 'outbound';
+    }
     return {
-        cosmosDbMode: cosmosResponse.mode || 'freetier',
-        vnetOption: vnetResponse.vnet || 'outbound'
+        cosmosDbMode: cosmosDbMode || 'freetier',
+        vnetOption: vnetOption || 'outbound',
+        swaPlan: swaPlan || 'standard'
     };
 }
 const VALID_CICD = ['github', 'azure', 'skip'];
+const VALID_BACKEND_LANGUAGE = ['typescript', 'csharp', 'python'];
 const VALID_COSMOS_DB_MODE = ['freetier', 'serverless'];
 const VALID_VNET = ['none', 'outbound'];
+const VALID_SWA_PLAN = ['free', 'standard'];
 function validateInitFlags(options) {
     if (options.cicd && !VALID_CICD.includes(options.cicd)) {
         console.error(`❌ Invalid --cicd value: "${options.cicd}". Must be: ${VALID_CICD.join(', ')}`);
         process.exit(1);
     }
+    if (options.backendLanguage && !VALID_BACKEND_LANGUAGE.includes(options.backendLanguage)) {
+        console.error(`❌ Invalid --backend-language value: "${options.backendLanguage}". Must be: ${VALID_BACKEND_LANGUAGE.join(', ')}`);
+        process.exit(1);
+    }
     if (options.cosmosDbMode && !VALID_COSMOS_DB_MODE.includes(options.cosmosDbMode)) {
         console.error(`❌ Invalid --cosmos-db-mode value: "${options.cosmosDbMode}". Must be: ${VALID_COSMOS_DB_MODE.join(', ')}`);
         process.exit(1);
@@ -98,6 +275,10 @@ function validateInitFlags(options) {
         console.error(`❌ Invalid --vnet value: "${options.vnet}". Must be: ${VALID_VNET.join(', ')}`);
         process.exit(1);
     }
+    if (options.swaPlan && !VALID_SWA_PLAN.includes(options.swaPlan)) {
+        console.error(`❌ Invalid --swa-plan value: "${options.swaPlan}". Must be: ${VALID_SWA_PLAN.join(', ')}`);
+        process.exit(1);
+    }
 }
 async function initCommand(options) {
     // Validate flag values before doing anything
@@ -115,26 +296,46 @@ async function initCommand(options) {
             console.error(`❌ Directory "${options.name}" already exists.`);
             process.exit(1);
         }
+        // 非対話環境でプロンプトに入るとハングするため、不足フラグを明示エラーで案内する
+        const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true && !process.env.CI;
+        if (!interactive) {
+            const missing = [];
+            if (!options.cicd)
+                missing.push('--cicd <github|azure|skip>');
+            if (!options.backendLanguage)
+                missing.push('--backend-language <typescript|csharp|python>');
+            if (!options.cosmosDbMode)
+                missing.push('--cosmos-db-mode <freetier|serverless>');
+            if (!options.vnet)
+                missing.push('--vnet <outbound|none>');
+            if (!options.swaPlan)
+                missing.push('--swa-plan <free|standard>');
+            if (missing.length > 0) {
+                console.error(`❌ Non-interactive environment detected. Pass all configuration flags to run init without prompts:\n` +
+                    missing.map((flag) => `   ${flag}`).join('\n'));
+                process.exit(1);
+            }
+        }
         // Use flag values if provided, otherwise prompt interactively
         const cicdProvider = options.cicd || await promptCiCd();
-        const azureConfig = (options.cosmosDbMode && options.vnet)
-            ? { cosmosDbMode: options.cosmosDbMode, vnetOption: options.vnet }
-            : await promptAzureConfig();
+        const backendLanguage = options.backendLanguage || await promptBackendLanguage();
+        const azureConfig = await promptAzureConfig(options);
         // Create Next.js project with create-next-app
         await createNextJsProject(options.name, pm);
         // Upgrade Next.js to specified version (or latest) to avoid cached old versions
         await upgradeNextJs(projectDir, options.nextVersion || 'latest', pm);
         // Add SwallowKit specific files
-        await addSwallowKitFiles(projectDir, options, cicdProvider, azureConfig, pm);
+        await addSwallowKitFiles(projectDir, options, cicdProvider, azureConfig, pm, backendLanguage);
         // Create infrastructure files (Bicep)
-        await createInfrastructure(projectDir, options.name, azureConfig);
+        await createInfrastructure(projectDir, options.name, azureConfig, backendLanguage);
         // Create CI/CD files based on choice
         if (cicdProvider === 'github') {
-            await createGitHubActionsWorkflows(projectDir, azureConfig, pm);
+            await createGitHubActionsWorkflows(projectDir, azureConfig, pm, backendLanguage);
         }
         else if (cicdProvider === 'azure') {
-            await createAzurePipelines(projectDir, pm);
+            await createAzurePipelines(projectDir, pm, backendLanguage);
         }
+        await (0, manifest_1.syncProjectManifest)(projectDir);
         // Initialize Git repository and create initial commit
         try {
             // Try git init with -b main (Git 2.28+), fallback to git init
@@ -179,7 +380,7 @@ async function initCommand(options) {
         console.log("\n📝 Next steps:");
         console.log(`  cd ${options.name}`);
         console.log(`  ${pmCmd.dlx} swallowkit create-model <name>  # Create your first model`);
-        console.log(`  ${pmCmd.dlx} swallowkit scaffold lib/models/<name>.ts  # Generate CRUD code`);
+        console.log(`  ${pmCmd.dlx} swallowkit scaffold shared/models/<name>.ts  # Generate CRUD code`);
         console.log(`  ${pmCmd.dlx} swallowkit dev  # Start development servers`);
         console.log("\n🚀 Deploy to Azure:");
         console.log(`  ${pmCmd.dlx} swallowkit provision --resource-group <name>`);
@@ -238,92 +439,416 @@ async function createNextJsProject(projectName, pm) {
     });
 }
 async function upgradeNextJs(projectDir, version, pm) {
-    return new Promise((resolve, reject) => {
-        console.log(`\n📦 Installing Next.js ${version} (to ensure latest security patches)...\n`);
-        // pnpm: pnpm add next@... ; npm: npm install next@...
-        const args = pm === 'pnpm'
-            ? ['add', `next@${version}`, `react@latest`, `react-dom@latest`, '--save-exact']
-            : ['install', `next@${version}`, `react@latest`, `react-dom@latest`, '--save-exact'];
-        const child = (0, child_process_1.spawn)(pm, args, {
-            cwd: projectDir,
-            stdio: 'inherit',
-            shell: true,
+    console.log(`\n📦 Installing Next.js ${version} (to ensure latest security patches)...\n`);
+    // pnpm: pnpm add next@... ; npm: npm install next@...
+    const args = pm === 'pnpm'
+        ? ['add', `next@${version}`, `react@latest`, `react-dom@latest`, '--save-exact']
+        : ['install', `next@${version}`, `react@latest`, `react-dom@latest`, '--save-exact'];
+    await runPackageManagerCommand(pm, args, projectDir, `${pm} add next@${version}`);
+    console.log(`\n✅ Next.js ${version} installed\n`);
+}
+async function installDependencies(projectDir, pm = 'pnpm') {
+    console.log('\n📦 Installing dependencies...\n');
+    await runPackageManagerCommand(pm, ['install'], projectDir, `${pm} install`);
+    if (pm === 'pnpm') {
+        console.log('\n📦 Generating npm lockfile for CI/CD...\n');
+        await withNpmLockfileSafeManifests(projectDir, async () => {
+            await runPackageManagerCommand('npm', ['install', '--package-lock-only', '--ignore-scripts'], projectDir, 'npm install --package-lock-only');
         });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`${pm} add next@${version} exited with code ${code}`));
+    }
+    console.log('\n✅ Dependencies installed\n');
+}
+async function withNpmLockfileSafeManifests(projectDir, action) {
+    const packageJsonPath = path.join(projectDir, 'package.json');
+    const functionsPackageJsonPath = path.join(projectDir, 'functions', 'package.json');
+    const sharedPackageJsonPath = path.join(projectDir, 'shared', 'package.json');
+    const originalFiles = new Map();
+    const hiddenNodeModules = new Map();
+    function rememberOriginal(filePath) {
+        if (!originalFiles.has(filePath)) {
+            originalFiles.set(filePath, fs.readFileSync(filePath, 'utf-8'));
+        }
+    }
+    function readJson(filePath) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    function writeJson(filePath, value) {
+        fs.writeFileSync(filePath, JSON.stringify(value, null, 2));
+    }
+    const sharedPackageName = fs.existsSync(sharedPackageJsonPath)
+        ? readJson(sharedPackageJsonPath).name
+        : undefined;
+    function replaceSharedWorkspaceDependency(packageJson, replacement) {
+        let changed = false;
+        for (const section of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+            const dependencies = packageJson[section];
+            if (!dependencies)
+                continue;
+            for (const [name, version] of Object.entries(dependencies)) {
+                if (version.startsWith('workspace:') && (name === sharedPackageName || name.endsWith('/shared'))) {
+                    dependencies[name] = replacement;
+                    changed = true;
+                }
             }
-            else {
-                console.log(`\n✅ Next.js ${version} installed\n`);
-                resolve();
+        }
+        return changed;
+    }
+    function normalizePackageJson(filePath, replacement) {
+        if (!fs.existsSync(filePath))
+            return;
+        const packageJson = readJson(filePath);
+        if (!replaceSharedWorkspaceDependency(packageJson, replacement))
+            return;
+        rememberOriginal(filePath);
+        writeJson(filePath, packageJson);
+    }
+    function hideNodeModules(directory) {
+        const nodeModulesPath = path.join(directory, 'node_modules');
+        if (!fs.existsSync(nodeModulesPath))
+            return;
+        const hiddenPath = path.join(directory, `.node_modules.swallowkit-npm-lockfile-${process.pid}`);
+        fs.renameSync(nodeModulesPath, hiddenPath);
+        hiddenNodeModules.set(nodeModulesPath, hiddenPath);
+    }
+    try {
+        normalizePackageJson(packageJsonPath, 'file:shared');
+        normalizePackageJson(functionsPackageJsonPath, 'file:../shared');
+        hideNodeModules(projectDir);
+        hideNodeModules(path.join(projectDir, 'shared'));
+        hideNodeModules(path.join(projectDir, 'functions'));
+        await action();
+    }
+    finally {
+        for (const [nodeModulesPath, hiddenPath] of hiddenNodeModules) {
+            if (fs.existsSync(nodeModulesPath)) {
+                fs.rmSync(nodeModulesPath, { recursive: true, force: true });
             }
-        });
-        child.on('error', (error) => {
-            reject(error);
-        });
-    });
+            fs.renameSync(hiddenPath, nodeModulesPath);
+        }
+        for (const [filePath, content] of originalFiles) {
+            fs.writeFileSync(filePath, content);
+        }
+    }
 }
-async function installDependencies(projectDir, pm = 'pnpm') {
+/**
+ * Run a package-manager command with stdio passed through to the user.
+ *
+ * For pnpm, additionally tee stdout/stderr to a buffer so that if the command
+ * fails due to `ERR_PNPM_IGNORED_BUILDS`, we can:
+ *   1. detect which packages were ignored,
+ *   2. approve them (interactively or automatically),
+ *   3. clean-reinstall and retry — repeating if pnpm reports further ignored
+ *      packages (pnpm does not always list every unapproved package at once).
+ */
+async function runPackageManagerCommand(pm, args, projectDir, label) {
+    let { code, output } = await spawnAndCapture(pm, args, projectDir, pm === 'pnpm');
+    if (code === 0)
+        return;
+    if (pm === 'pnpm') {
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const ignoredBuilds = parseIgnoredBuilds(output);
+            if (ignoredBuilds.length === 0)
+                break;
+            const approved = await maybeApproveBuilds(projectDir, ignoredBuilds);
+            if (!approved)
+                break;
+            // 中断された install はパッケージ抽出が不完全なまま "Already up to date"
+            // と判定されることがあるため、node_modules を消して決定論的に入れ直す
+            removeWorkspaceNodeModules(projectDir);
+            const retry = await spawnAndCapture(pm, args, projectDir, true);
+            code = retry.code;
+            output = retry.output;
+            if (code === 0)
+                return;
+        }
+        if (parseIgnoredBuilds(output).length > 0) {
+            throw new Error(`${label} exited with code ${code}: pnpm still reports unapproved build scripts. ` +
+                'Run "pnpm approve-builds" inside the project, then re-run the command.');
+        }
+    }
+    throw new Error(`${label} exited with code ${code}`);
+}
+/** workspace root と直下パッケージの node_modules を削除する(クリーン再インストール用)。 */
+function removeWorkspaceNodeModules(projectDir) {
+    const targets = [projectDir, ...fs.readdirSync(projectDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.'))
+            .map((entry) => path.join(projectDir, entry.name))];
+    for (const dir of targets) {
+        const nodeModules = path.join(dir, 'node_modules');
+        if (fs.existsSync(nodeModules)) {
+            fs.rmSync(nodeModules, { recursive: true, force: true });
+        }
+    }
+}
+/**
+ * Spawn a child process inheriting stdin (so interactive prompts still work)
+ * while either inheriting or capturing+teeing stdout/stderr.
+ */
+function spawnAndCapture(pm, args, projectDir, capture) {
     return new Promise((resolve, reject) => {
-        console.log('\n📦 Installing dependencies...\n');
-        const child = (0, child_process_1.spawn)(pm, ['install'], {
+        const stdio = capture
+            ? ['inherit', 'pipe', 'pipe']
+            : ['inherit', 'inherit', 'inherit'];
+        const child = (0, child_process_1.spawn)(pm, args, {
             cwd: projectDir,
-            stdio: 'inherit',
+            stdio,
             shell: true,
         });
+        let combined = '';
+        if (capture) {
+            child.stdout?.on('data', (chunk) => {
+                process.stdout.write(chunk);
+                combined += chunk.toString('utf8');
+            });
+            child.stderr?.on('data', (chunk) => {
+                process.stderr.write(chunk);
+                combined += chunk.toString('utf8');
+            });
+        }
+        child.on('close', (code) => resolve({ code: code ?? 0, output: combined }));
+        child.on('error', reject);
+    });
+}
+/**
+ * Parse pnpm's `Ignored build scripts: foo@1.0.0, bar@2.0.0` warning/error and
+ * return the bare package names (without versions), de-duplicated.
+ */
+function parseIgnoredBuilds(output) {
+    const match = output.match(/Ignored build scripts:\s*([^\n\r]+)/i);
+    if (!match)
+        return [];
+    const list = match[1]
+        .split(',')
+        .map((entry) => entry.trim())
+        // strip version suffix: `sharp@0.34.5` -> `sharp`, `@scope/pkg@1.0.0` -> `@scope/pkg`
+        .map((entry) => entry.replace(/@[^@]+$/, ''))
+        .filter((name) => name.length > 0);
+    return Array.from(new Set(list));
+}
+/**
+ * Prompt the user and, if approved, run `pnpm approve-builds` followed by
+ * `pnpm rebuild <packages>`. Returns true if the user approved (regardless of
+ * which packages they actually selected inside approve-builds).
+ *
+ * In non-interactive environments (CI, coding agents, piped output) prompting
+ * would hang forever, so build scripts are approved automatically via
+ * package.json `pnpm.onlyBuiltDependencies` instead.
+ */
+async function maybeApproveBuilds(projectDir, ignoredBuilds) {
+    console.log(`\n⚠️  pnpm refused to run build scripts for: ${ignoredBuilds.join(', ')}\n` +
+        '   These packages (e.g. sharp) need their build scripts to run correctly.\n');
+    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true && !process.env.CI;
+    if (!interactive) {
+        console.log('ℹ️  Non-interactive environment detected — approving build scripts automatically\n' +
+            '   via "allowBuilds" in pnpm-workspace.yaml.\n');
+        // rebuild は不要: 呼び出し側がクリーン再インストールで build script を実行する
+        approveBuildsViaWorkspaceYaml(projectDir, ignoredBuilds);
+        return true;
+    }
+    const response = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'approve',
+        message: 'Run `pnpm approve-builds` now to approve these build scripts?',
+        initial: true,
+    });
+    if (!response.approve) {
+        console.log('\nℹ️  Skipped. You can run `pnpm approve-builds` later inside the project directory.\n');
+        return false;
+    }
+    await runSimple('pnpm', ['approve-builds'], projectDir);
+    await runSimple('pnpm', ['rebuild', ...ignoredBuilds], projectDir);
+    console.log('\n✅ Build scripts approved and packages rebuilt\n');
+    return true;
+}
+/**
+ * pnpm-workspace.yaml の allowBuilds にパッケージを true で登録して build script を許可する。
+ * (pnpm 11+ の正準設定。失敗時に pnpm が追記する placeholder 行も true に置き換える)
+ */
+function approveBuildsViaWorkspaceYaml(projectDir, packages) {
+    const workspaceYamlPath = path.join(projectDir, 'pnpm-workspace.yaml');
+    const existing = fs.existsSync(workspaceYamlPath)
+        ? fs.readFileSync(workspaceYamlPath, 'utf-8')
+        : '';
+    const yamlKey = (pkg) => (/^[A-Za-z0-9_.-]+$/.test(pkg) ? pkg : `'${pkg}'`);
+    const lines = existing.length > 0 ? existing.split(/\r?\n/) : [];
+    const keyIndex = lines.findIndex((line) => /^allowBuilds\s*:/.test(line));
+    if (keyIndex === -1) {
+        const block = `allowBuilds:\n${packages.map((pkg) => `  ${yamlKey(pkg)}: true`).join('\n')}\n`;
+        const base = existing.length > 0 && !existing.endsWith('\n') ? `${existing}\n` : existing;
+        fs.writeFileSync(workspaceYamlPath, `${base}${block}`, 'utf-8');
+        return;
+    }
+    // 既存マップ内の対象パッケージ(placeholder 含む)を true に更新し、無いものは追記する
+    let endIndex = keyIndex + 1;
+    const updated = new Set();
+    while (endIndex < lines.length && /^\s+\S/.test(lines[endIndex])) {
+        const entry = lines[endIndex].match(/^\s+['"]?([A-Za-z0-9@/_.-]+)['"]?\s*:/);
+        if (entry && packages.includes(entry[1])) {
+            lines[endIndex] = `  ${yamlKey(entry[1])}: true`;
+            updated.add(entry[1]);
+        }
+        endIndex++;
+    }
+    const additions = packages.filter((pkg) => !updated.has(pkg)).map((pkg) => `  ${yamlKey(pkg)}: true`);
+    lines.splice(endIndex, 0, ...additions);
+    fs.writeFileSync(workspaceYamlPath, lines.join('\n'), 'utf-8');
+}
+function runSimple(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, { cwd, stdio: 'inherit', shell: true });
         child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`${pm} install exited with code ${code}`));
-            }
-            else {
-                console.log('\n✅ Dependencies installed\n');
+            if (code !== 0)
+                reject(new Error(`${command} ${args.join(' ')} exited with code ${code}`));
+            else
                 resolve();
-            }
-        });
-        child.on('error', (error) => {
-            reject(error);
         });
+        child.on('error', reject);
     });
 }
-async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig, pm) {
+function injectSwallowKitNextConfig(nextConfigContent, projectName) {
+    return nextConfigContent.replace(/(const\s+nextConfig[:\s]*(?::\s*NextConfig\s*)?=\s*\{)(\s*\/\*[^*]*\*\/)?/, `$1\n  output: 'standalone',\n  agentRules: false, // SwallowKit owns the canonical root AGENTS.md contract\n  transpilePackages: ['@${projectName}/shared'],\n  serverExternalPackages: ['applicationinsights', 'diagnostic-channel-publishers'],$2`);
+}
+function buildCSharpFunctionsProgramSource() {
+    return `using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Azure.Functions.Worker.ApplicationInsights;
+
+var host = new HostBuilder()
+    .ConfigureFunctionsWorkerDefaults()
+    .ConfigureServices(services =>
+    {
+        services.AddApplicationInsightsTelemetryWorkerService();
+        services.ConfigureFunctionsApplicationInsights();
+    })
+    .Build();
+
+host.Run();
+`;
+}
+function buildCSharpFunctionsProjectSource() {
+    return `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <AzureFunctionsVersion>v4</AzureFunctionsVersion>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Remove="generated\\**\\bin\\**\\*.cs;generated\\**\\obj\\**\\*.cs" />
+    <EmbeddedResource Remove="generated\\**\\bin\\**;generated\\**\\obj\\**" />
+    <None Remove="generated\\**\\bin\\**;generated\\**\\obj\\**" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Cosmos" Version="3.47.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="Azure.Identity" Version="1.17.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="2.52.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.3.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="2.0.7" OutputItemType="Analyzer" />
+    <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.ApplicationInsights" Version="2.50.0" />
+  </ItemGroup>
+</Project>
+`;
+}
+function buildSwallowKitConfigSource(backendLanguage) {
+    return `module.exports = {
+  backend: {
+    language: '${backendLanguage}',
+  },
+  functions: {
+    baseUrl: process.env.BACKEND_FUNCTIONS_BASE_URL || process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071',
+  },
+  deployment: {
+    resourceGroup: process.env.AZURE_RESOURCE_GROUP || '',
+    swaName: process.env.AZURE_SWA_NAME || '',
+  },
+}
+`;
+}
+function buildGeneratedProjectDependencies(projectName, pm = 'pnpm') {
+    return {
+        '@azure/cosmos': '^4.0.0',
+        'applicationinsights': '^3.3.0',
+        'zod': '^4.0.0',
+        [`@${projectName}/shared`]: pm === 'pnpm' ? 'workspace:*' : 'file:shared',
+    };
+}
+function getSwallowKitPackageMetadata() {
+    const packageJsonPath = path.resolve(__dirname, "..", "..", "..", "package.json");
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        return {
+            name: packageJson.name || "swallowkit",
+            version: packageJson.version || "latest",
+        };
+    }
+    catch {
+        // Fall back to the published package name when package metadata is unavailable.
+    }
+    return {
+        name: "swallowkit",
+        version: "latest",
+    };
+}
+function buildGeneratedProjectDevDependencies() {
+    const { name, version } = getSwallowKitPackageMetadata();
+    return {
+        [name]: version,
+    };
+}
+function buildSwallowKitMcpProjectConfigSource(pm = 'pnpm') {
+    const { name } = getSwallowKitPackageMetadata();
+    return JSON.stringify({
+        mcpServers: {
+            swallowkit: {
+                command: pm === 'pnpm' ? 'pnpm' : 'npx',
+                args: pm === 'pnpm'
+                    ? ["dlx", "--package", `${name}@\${SWALLOWKIT_MCP_VERSION}`, "swallowkit-mcp"]
+                    : ["--yes", "--package", `${name}@\${SWALLOWKIT_MCP_VERSION}`, "swallowkit-mcp"],
+                cwd: ".",
+                env: {
+                    SWALLOWKIT_MCP_VERSION: "latest",
+                },
+            },
+        },
+    }, null, 2);
+}
+async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig, pm, backendLanguage) {
     console.log('📦 Adding SwallowKit files...\n');
     const projectName = options.name;
-    // 1. Update package.json to add swallowkit and @azure/cosmos dependencies
+    // 1. Update package.json to add runtime dependencies for generated projects
     const packageJsonPath = path.join(projectDir, 'package.json');
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-    // Add SwallowKit dependencies (Next.js version already upgraded by upgradeNextJs)
     // zod is in the shared workspace package, not here
     packageJson.dependencies = {
         ...packageJson.dependencies,
-        'swallowkit': 'latest',
-        '@azure/cosmos': '^4.0.0',
-        'applicationinsights': '^3.3.0',
-        [`@${projectName}/shared`]: '*',
+        ...buildGeneratedProjectDependencies(projectName, pm),
+    };
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies,
+        ...buildGeneratedProjectDevDependencies(),
     };
     packageJson.scripts = {
         ...packageJson.scripts,
         'build': (0, package_manager_1.getBuildScript)(pm),
         'start': 'next start',
-        'functions:start': (0, package_manager_1.getFunctionsStartScript)(pm),
+        'functions:start': (0, package_manager_1.getFunctionsStartScript)(pm, backendLanguage),
     };
-    if (pm === 'pnpm') {
-        packageJson.packageManager = 'pnpm@latest';
-    }
     packageJson.engines = {
         node: '20.x',
     };
-    // Workspace configuration depends on package manager
-    const wsConfig = (0, package_manager_1.getWorkspaceConfig)(pm, ['shared', 'functions']);
-    if (wsConfig.type === 'file') {
-        // pnpm: workspaces are defined in pnpm-workspace.yaml
-        delete packageJson.workspaces;
-    }
-    else {
-        // npm: workspaces are defined in package.json
+    // Keep package.json workspaces for npm-based CI/CD even when local development uses pnpm.
+    const workspacePackages = usesNodeFunctionsProject(backendLanguage) ? ['shared', 'functions'] : ['shared'];
+    const wsConfig = (0, package_manager_1.getWorkspaceConfig)(pm, workspacePackages);
+    packageJson.workspaces = workspacePackages;
+    if (wsConfig.type !== 'file') {
         packageJson.workspaces = wsConfig.value;
     }
     fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
-    // Create workspace config file if needed (pnpm-workspace.yaml)
+    // Create pnpm-workspace.yaml for local pnpm development when needed.
     if (wsConfig.type === 'file') {
         fs.writeFileSync(path.join(projectDir, wsConfig.filename), wsConfig.content);
     }
@@ -336,11 +861,9 @@ async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig,
     }
     if (fs.existsSync(nextConfigPath)) {
         let nextConfigContent = fs.readFileSync(nextConfigPath, 'utf-8');
-        // Add output: 'standalone', experimental.turbopackUseSystemTlsCerts, and serverExternalPackages
+        // Add output, transpiled workspace package, and server externals for standalone deployment
         if (!nextConfigContent.includes("output:") && !nextConfigContent.includes('output =')) {
-            // Handle TypeScript config format: const nextConfig: NextConfig = {
-            // Handle JavaScript config format: const nextConfig = {
-            nextConfigContent = nextConfigContent.replace(/(const\s+nextConfig[:\s]*(?::\s*NextConfig\s*)?=\s*\{)(\s*\/\*[^*]*\*\/)?/, `$1\n  output: 'standalone',\n  transpilePackages: ['@${projectName}/shared'],\n  experimental: {\n    turbopackUseSystemTlsCerts: true,\n  },\n  serverExternalPackages: ['applicationinsights', 'diagnostic-channel-publishers'],$2`);
+            nextConfigContent = injectSwallowKitNextConfig(nextConfigContent, projectName);
             fs.writeFileSync(nextConfigPath, nextConfigContent);
         }
     }
@@ -360,17 +883,7 @@ async function addSwallowKitFiles(projectDir, options, cicdChoice, azureConfig,
         fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
     }
     // 3. Create SwallowKit config
-    const swallowkitConfig = `/** @type {import('swallowkit').SwallowKitConfig} */
-module.exports = {
-  functions: {
-    baseUrl: process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071',
-  },
-  deployment: {
-    resourceGroup: process.env.AZURE_RESOURCE_GROUP || '',
-    swaName: process.env.AZURE_SWA_NAME || '',
-  },
-}
-`;
+    const swallowkitConfig = buildSwallowKitConfigSource(backendLanguage);
     fs.writeFileSync(path.join(projectDir, 'swallowkit.config.js'), swallowkitConfig);
     // 4. Create shared workspace package for Zod models (Single Source of Truth)
     await createSharedPackage(projectDir, projectName);
@@ -382,7 +895,14 @@ module.exports = {
     // Create backend utility for calling Azure Functions
     const backendUtilContent = `// Get Functions base URL at runtime (not at build time)
 function getFunctionsBaseUrl(): string {
-  return process.env.BACKEND_FUNCTIONS_BASE_URL || 'http://localhost:7071';
+  return process.env.BACKEND_FUNCTIONS_BASE_URL || process.env.FUNCTIONS_BASE_URL || 'http://localhost:7071';
+}
+
+function getFunctionsKeyHeaders(functionsBaseUrl: string): Record<string, string> {
+  const key = process.env.BACKEND_FUNCTIONS_KEY;
+  if (key) return { 'x-functions-key': key };
+  if (functionsBaseUrl.startsWith('http://localhost:') || functionsBaseUrl.startsWith('http://127.0.0.1:')) return {};
+  throw new Error('BACKEND_FUNCTIONS_KEY is required for non-local Functions calls');
 }
 
 /**
@@ -392,10 +912,11 @@ function getFunctionsBaseUrl(): string {
 async function request<T>(
   endpoint: string,
   method: 'GET' | 'POST' | 'PUT' | 'DELETE',
-  body?: any,
+  body?: unknown,
   queryParams?: Record<string, string>
 ): Promise<T> {
   const functionsBaseUrl = getFunctionsBaseUrl();
+  const keyHeaders = getFunctionsKeyHeaders(functionsBaseUrl);
   let url = \`\${functionsBaseUrl}\${endpoint}\`;
   if (queryParams) {
     const params = new URLSearchParams(queryParams);
@@ -407,6 +928,7 @@ async function request<T>(
       method,
       headers: {
         'Content-Type': 'application/json',
+        ...keyHeaders,
       },
       body: body ? JSON.stringify(body) : undefined,
     });
@@ -462,14 +984,14 @@ export const api = {
   /**
    * Make a POST request
    */
-  post: <T>(endpoint: string, body?: any): Promise<T> => {
+  post: <T>(endpoint: string, body?: unknown): Promise<T> => {
     return request<T>(endpoint, 'POST', body);
   },
 
   /**
    * Make a PUT request
    */
-  put: <T>(endpoint: string, body?: any): Promise<T> => {
+  put: <T>(endpoint: string, body?: unknown): Promise<T> => {
     return request<T>(endpoint, 'PUT', body);
   },
 
@@ -487,7 +1009,8 @@ export const api = {
     fs.mkdirSync(componentsDir, { recursive: true });
     // 6. Create .env.example
     const envExample = `# Azure Functions Backend URL
-FUNCTIONS_BASE_URL=http://localhost:7071
+BACKEND_FUNCTIONS_BASE_URL=http://localhost:7071
+BACKEND_FUNCTIONS_KEY=
 
 # Azure Configuration
 AZURE_RESOURCE_GROUP=your-resource-group
@@ -526,7 +1049,7 @@ export async function register() {
       const originalConsoleError = console.error;
       const originalConsoleWarn = console.warn;
       
-      console.log = function(...args: any[]) {
+      console.log = function(...args: unknown[]) {
         originalConsoleLog.apply(console, args);
         const message = args.map(arg => 
           typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
@@ -537,7 +1060,7 @@ export async function register() {
         });
       };
       
-      console.error = function(...args: any[]) {
+      console.error = function(...args: unknown[]) {
         originalConsoleError.apply(console, args);
         const message = args.map(arg => 
           typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
@@ -548,7 +1071,7 @@ export async function register() {
         });
       };
       
-      console.warn = function(...args: any[]) {
+      console.warn = function(...args: unknown[]) {
         originalConsoleWarn.apply(console, args);
         const message = args.map(arg => 
           typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
@@ -570,7 +1093,8 @@ export async function register() {
     // 8. Create .env.local for local development
     const envLocalContent = [
         '# Azure Functions Backend URL (Local)',
-        'FUNCTIONS_BASE_URL=http://localhost:7071',
+        'BACKEND_FUNCTIONS_BASE_URL=http://localhost:7071',
+        'BACKEND_FUNCTIONS_KEY=',
         ''
     ].join('\n');
     fs.writeFileSync(path.join(projectDir, '.env.local'), envLocalContent);
@@ -596,7 +1120,7 @@ export async function register() {
     };
     fs.writeFileSync(path.join(projectDir, 'staticwebapp.config.json'), JSON.stringify(swaConfig, null, 2));
     // 14. Create Azure Functions project
-    await createAzureFunctionsProject(projectDir, pm);
+    await createAzureFunctionsProject(projectDir, pm, backendLanguage);
     // 15. Create BFF API route to call Azure Functions
     await createBffApiRoute(projectDir);
     // 16. Create home page
@@ -606,9 +1130,9 @@ export async function register() {
     await installDependencies(projectDir, pm);
     console.log('✅ Project structure created\n');
     // 18. Create README.md
-    createReadme(projectDir, projectName, cicdChoice, azureConfig, pm);
+    createReadme(projectDir, projectName, cicdChoice, azureConfig, pm, backendLanguage);
     // 19. Create AI agent instruction files (AGENTS.md, CLAUDE.md, .github/copilot-instructions.md, etc.)
-    createAiAgentFiles(projectDir, projectName);
+    createAiAgentFiles(projectDir, projectName, backendLanguage, pm);
 }
 async function createSharedPackage(projectDir, projectName) {
     console.log('📦 Creating shared workspace package for Zod models...\n');
@@ -617,6 +1141,7 @@ async function createSharedPackage(projectDir, projectName) {
     fs.mkdirSync(modelsDir, { recursive: true });
     // shared/package.json
     const sharedPackageJson = {
+        private: true,
         name: `@${projectName}/shared`,
         version: '1.0.0',
         description: 'Shared Zod models — Single Source of Truth for validation schemas',
@@ -635,61 +1160,127 @@ async function createSharedPackage(projectDir, projectName) {
     };
     fs.writeFileSync(path.join(sharedDir, 'package.json'), JSON.stringify(sharedPackageJson, null, 2));
     // shared/tsconfig.json
-    const sharedTsConfig = {
-        compilerOptions: {
-            target: 'ES2020',
-            module: 'commonjs',
-            moduleResolution: 'node',
-            lib: ['ES2020'],
-            outDir: 'dist',
-            rootDir: '.',
-            declaration: true,
-            declarationMap: true,
-            sourceMap: true,
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            forceConsistentCasingInFileNames: true,
-        },
-        include: ['index.ts', 'models/**/*'],
-        exclude: ['node_modules', 'dist'],
-    };
-    fs.writeFileSync(path.join(sharedDir, 'tsconfig.json'), JSON.stringify(sharedTsConfig, null, 2));
+    fs.writeFileSync(path.join(sharedDir, 'tsconfig.json'), JSON.stringify(buildSharedTsConfig(), null, 2));
     // shared/index.ts (empty re-export file, scaffold will add entries)
     fs.writeFileSync(path.join(sharedDir, 'index.ts'), `// Shared Zod models — auto-managed by SwallowKit scaffold command\n// Do not edit the export list below manually\n`);
     // shared/.gitignore
     fs.writeFileSync(path.join(sharedDir, '.gitignore'), `node_modules\ndist\n`);
     console.log('✅ Shared package created\n');
 }
-async function createAzureFunctionsProject(projectDir, pm = 'pnpm') {
-    console.log('📦 Creating Azure Functions project...\n');
+async function createAzureFunctionsProject(projectDir, pm = 'pnpm', backendLanguage = 'typescript') {
+    console.log(`📦 Creating Azure Functions project (${getBackendLanguageLabel(backendLanguage)})...\n`);
     const functionsDir = path.join(projectDir, 'functions');
     fs.mkdirSync(functionsDir, { recursive: true });
-    // Create functions package.json
-    const functionsPackageJson = {
-        name: 'functions',
-        version: '1.0.0',
-        description: 'Azure Functions backend',
-        main: 'dist/*.js',
-        scripts: {
-            start: 'func start',
-            build: 'tsc',
-            prestart: (0, package_manager_1.getFunctionsPrestart)(pm)
-        },
-        dependencies: {
-            '@azure/functions': '~4.5.0',
-            '@azure/cosmos': '^4.0.0',
-            '@azure/identity': '^4.0.0',
-            'zod': '>=3.25.0',
-            [`@${path.basename(projectDir)}/shared`]: '*',
-        },
-        devDependencies: {
-            '@types/node': '^20.0.0',
-            'typescript': '^5.0.0'
-        }
+    const projectName = path.basename(projectDir);
+    const databaseName = `${projectName.charAt(0).toUpperCase() + projectName.slice(1)}Database`;
+    createFunctionsHostFiles(functionsDir, databaseName, backendLanguage);
+    if (backendLanguage === 'typescript') {
+        createTypeScriptFunctionsProject(projectDir, functionsDir, pm);
+    }
+    else if (backendLanguage === 'csharp') {
+        createCSharpFunctionsProject(projectDir, functionsDir);
+    }
+    else {
+        createPythonFunctionsProject(projectDir, functionsDir);
+    }
+    console.log('✅ Azure Functions project created\n');
+}
+function createFunctionsHostFiles(functionsDir, databaseName, backendLanguage) {
+    const hostJson = {
+        version: '2.0',
+        logging: {
+            applicationInsights: {
+                samplingSettings: {
+                    isEnabled: true,
+                    maxTelemetryItemsPerSecond: 20,
+                },
+            },
+        },
+        extensionBundle: {
+            id: 'Microsoft.Azure.Functions.ExtensionBundle',
+            version: '[4.0.0, 4.10.0)',
+        },
+    };
+    fs.writeFileSync(path.join(functionsDir, 'host.json'), JSON.stringify(hostJson, null, 2));
+    const localSettings = {
+        IsEncrypted: false,
+        Values: {
+            AzureWebJobsStorage: '',
+            FUNCTIONS_WORKER_RUNTIME: getFunctionsWorkerRuntime(backendLanguage),
+            AzureWebJobsFeatureFlags: 'EnableWorkerIndexing',
+            CosmosDBConnection: 'AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==',
+            COSMOS_DB_DATABASE_NAME: databaseName,
+            NODE_TLS_REJECT_UNAUTHORIZED: '0',
+        },
+    };
+    fs.writeFileSync(path.join(functionsDir, 'local.settings.json'), JSON.stringify(localSettings, null, 2));
+    const gitignoreLines = [
+        'local.settings.json',
+        '*.log',
+        '.vscode',
+        '.DS_Store',
+    ];
+    if (backendLanguage === 'typescript') {
+        gitignoreLines.unshift('node_modules', 'dist');
+        fs.writeFileSync(path.join(functionsDir, '.funcignore'), `node_modules
+.git
+.vscode
+local.settings.json
+test
+tsconfig.json
+*.ts
+!dist/**/*.js
+`);
+    }
+    else if (backendLanguage === 'python') {
+        gitignoreLines.unshift('.venv', '.codegen-venv', '__pycache__', '.python_packages');
+        fs.writeFileSync(path.join(functionsDir, '.funcignore'), `.venv
+.codegen-venv
+__pycache__
+.pytest_cache
+.mypy_cache
+.ruff_cache
+local.settings.json
+tests
+`);
+    }
+    else {
+        gitignoreLines.unshift('bin', 'obj');
+        fs.writeFileSync(path.join(functionsDir, '.funcignore'), `bin
+obj
+local.settings.json
+tests
+`);
+    }
+    fs.writeFileSync(path.join(functionsDir, '.gitignore'), `${gitignoreLines.join('\n')}\n`);
+}
+function buildTypeScriptFunctionsPackageJson(projectName, pm = 'pnpm') {
+    return {
+        name: 'functions',
+        version: '1.0.0',
+        description: 'Azure Functions backend',
+        main: 'dist/*.js',
+        scripts: {
+            start: 'func start',
+            build: 'tsc',
+            prestart: (0, package_manager_1.getFunctionsPrestart)(pm),
+        },
+        dependencies: {
+            '@azure/functions': '~4.5.0',
+            '@azure/cosmos': '^4.0.0',
+            '@azure/identity': '^4.0.0',
+            zod: '>=3.25.0',
+            [`@${projectName}/shared`]: pm === 'pnpm' ? 'workspace:*' : 'file:../shared',
+        },
+        devDependencies: {
+            '@types/node': '^20.0.0',
+            typescript: '^5.0.0',
+        },
     };
+}
+function createTypeScriptFunctionsProject(projectDir, functionsDir, pm) {
+    const functionsPackageJson = buildTypeScriptFunctionsPackageJson(path.basename(projectDir), pm);
     fs.writeFileSync(path.join(functionsDir, 'package.json'), JSON.stringify(functionsPackageJson, null, 2));
-    // Create functions tsconfig.json
     const sharedPkgName = `@${path.basename(projectDir)}/shared`;
     const functionsTsConfig = {
         compilerOptions: {
@@ -709,69 +1300,14 @@ async function createAzureFunctionsProject(projectDir, pm = 'pnpm') {
             },
         },
         include: ['src/**/*'],
-        exclude: ['node_modules', 'dist']
+        exclude: ['node_modules', 'dist'],
     };
     fs.writeFileSync(path.join(functionsDir, 'tsconfig.json'), JSON.stringify(functionsTsConfig, null, 2));
-    // Create host.json
-    const hostJson = {
-        version: '2.0',
-        logging: {
-            applicationInsights: {
-                samplingSettings: {
-                    isEnabled: true,
-                    maxTelemetryItemsPerSecond: 20
-                }
-            }
-        },
-        extensionBundle: {
-            id: 'Microsoft.Azure.Functions.ExtensionBundle',
-            version: '[4.0.0, 4.10.0)'
-        }
-    };
-    fs.writeFileSync(path.join(functionsDir, 'host.json'), JSON.stringify(hostJson, null, 2));
-    // Create .funcignore
-    const funcignore = `node_modules
-.git
-.vscode
-local.settings.json
-test
-tsconfig.json
-*.ts
-!dist/**/*.js
-`;
-    fs.writeFileSync(path.join(functionsDir, '.funcignore'), funcignore);
-    // Create .gitignore for functions directory
-    const functionsGitignore = `node_modules
-dist
-local.settings.json
-*.log
-.vscode
-.DS_Store
-`;
-    fs.writeFileSync(path.join(functionsDir, '.gitignore'), functionsGitignore);
-    // Create local.settings.json
-    const projectName = path.basename(projectDir);
-    const databaseName = `${projectName.charAt(0).toUpperCase() + projectName.slice(1)}Database`;
-    const localSettings = {
-        IsEncrypted: false,
-        Values: {
-            AzureWebJobsStorage: '',
-            FUNCTIONS_WORKER_RUNTIME: 'node',
-            AzureWebJobsFeatureFlags: 'EnableWorkerIndexing',
-            CosmosDBConnection: 'AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==',
-            COSMOS_DB_DATABASE_NAME: databaseName,
-            NODE_TLS_REJECT_UNAUTHORIZED: '0'
-        }
-    };
-    fs.writeFileSync(path.join(functionsDir, 'local.settings.json'), JSON.stringify(localSettings, null, 2));
-    // Create src directory
     const srcDir = path.join(functionsDir, 'src');
     fs.mkdirSync(srcDir, { recursive: true });
-    // Create greet function directly in src
-    const greetFunction = `import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+    fs.writeFileSync(path.join(srcDir, 'greet.ts'), `import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
 import { z } from 'zod/v4';
 
-// Zod schema for request validation
 const greetRequestSchema = z.object({
   name: z.string().min(1, 'Name is required').max(50, 'Name must be less than 50 characters'),
 });
@@ -780,12 +1316,9 @@ export async function greet(request: HttpRequest, context: InvocationContext): P
   context.log('HTTP trigger function processed a request.');
 
   try {
-    // Get name from query or body
     const name = request.query.get('name') || (await request.text());
-    
-    // Validate with Zod
     const result = greetRequestSchema.safeParse({ name });
-    
+
     if (!result.success) {
       return {
         status: 400,
@@ -796,7 +1329,7 @@ export async function greet(request: HttpRequest, context: InvocationContext): P
     }
 
     const greeting = \`Hello, \${result.data.name}! This message is from Azure Functions.\`;
-    
+
     return {
       status: 200,
       jsonBody: {
@@ -817,13 +1350,109 @@ export async function greet(request: HttpRequest, context: InvocationContext): P
 
 app.http('greet', {
   methods: ['GET', 'POST'],
-  authLevel: 'anonymous',
+  authLevel: 'function',
   handler: greet
 });
-`;
-    fs.writeFileSync(path.join(srcDir, 'greet.ts'), greetFunction);
-    // Dependencies are installed via workspace root install
-    console.log('✅ Azure Functions project created\n');
+`);
+}
+function createCSharpFunctionsProject(projectDir, functionsDir) {
+    const projectBaseName = path.basename(projectDir);
+    const projectPascal = projectBaseName.charAt(0).toUpperCase() + projectBaseName.slice(1);
+    const csprojName = `${projectPascal}.Functions.csproj`;
+    fs.writeFileSync(path.join(functionsDir, csprojName), buildCSharpFunctionsProjectSource());
+    fs.mkdirSync(path.join(functionsDir, '.config'), { recursive: true });
+    fs.writeFileSync(path.join(functionsDir, '.config', 'dotnet-tools.json'), (0, native_schema_generator_1.buildCSharpCodegenToolManifestSource)());
+    fs.writeFileSync(path.join(functionsDir, 'Program.cs'), buildCSharpFunctionsProgramSource());
+    const crudDir = path.join(functionsDir, 'Crud');
+    fs.mkdirSync(crudDir, { recursive: true });
+    fs.writeFileSync(path.join(crudDir, 'GreetFunction.cs'), `using System.Net;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+
+namespace SwallowKit.Functions;
+
+public sealed class GreetFunction
+{
+    [Function("greet")]
+    public async Task<HttpResponseData> Run(
+        [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "greet")] HttpRequestData request)
+    {
+        var query = request.Url.Query.TrimStart('?').Split('&', StringSplitOptions.RemoveEmptyEntries);
+        var name = "SwallowKit";
+        foreach (var segment in query)
+        {
+            var parts = segment.Split('=', 2);
+            if (parts.Length == 2 && parts[0] == "name")
+            {
+                name = Uri.UnescapeDataString(parts[1]);
+                break;
+            }
+        }
+        var response = request.CreateResponse(HttpStatusCode.OK);
+        await response.WriteAsJsonAsync(new
+        {
+            message = $"Hello, {name}! This message is from Azure Functions.",
+            timestamp = DateTimeOffset.UtcNow.ToString("O"),
+        });
+        return response;
+    }
+}
+`);
+}
+function createPythonFunctionsProject(projectDir, functionsDir) {
+    fs.writeFileSync(path.join(projectDir, '.python-version'), '3.11\n');
+    ensureProjectGitignoreEntry(projectDir, '.uv');
+    fs.writeFileSync(path.join(functionsDir, 'requirements.txt'), `azure-functions>=1.20.0
+azure-cosmos>=4.9.0
+azure-identity>=1.19.0
+`);
+    fs.writeFileSync(path.join(functionsDir, 'requirements.codegen.txt'), (0, native_schema_generator_1.buildPythonCodegenRequirementsSource)());
+    const blueprintsDir = path.join(functionsDir, 'blueprints');
+    fs.mkdirSync(blueprintsDir, { recursive: true });
+    fs.writeFileSync(path.join(blueprintsDir, '__init__.py'), '');
+    fs.writeFileSync(path.join(blueprintsDir, 'greet.py'), `import json
+from datetime import datetime, timezone
+
+import azure.functions as func
+
+bp = func.Blueprint()
+
+
+@bp.route(route="greet", methods=["GET", "POST"])
+def greet(req: func.HttpRequest) -> func.HttpResponse:
+    name = req.params.get("name") or "SwallowKit"
+    payload = {
+        "message": f"Hello, {name}! This message is from Azure Functions.",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    }
+    return func.HttpResponse(
+        body=json.dumps(payload, ensure_ascii=False),
+        status_code=200,
+        mimetype="application/json",
+    )
+`);
+    fs.writeFileSync(path.join(functionsDir, 'function_app.py'), `import azure.functions as func
+
+from blueprints.greet import bp as greet_bp
+
+app = func.FunctionApp(http_auth_level=func.AuthLevel.FUNCTION)
+
+app.register_blueprint(greet_bp)
+# SwallowKit scaffold registrations
+`);
+}
+function ensureProjectGitignoreEntry(projectDir, entry) {
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        return;
+    }
+    const current = fs.readFileSync(gitignorePath, 'utf8');
+    const lines = current.split(/\r?\n/);
+    if (lines.includes(entry)) {
+        return;
+    }
+    const normalized = current.endsWith('\n') ? current : `${current}\n`;
+    fs.writeFileSync(gitignorePath, `${normalized}${entry}\n`);
 }
 async function createBffApiRoute(projectDir) {
     console.log('📦 Creating BFF API route...\n');
@@ -874,17 +1503,17 @@ export async function POST(request: NextRequest) {
 }
 `;
     fs.writeFileSync(path.join(apiDir, 'route.ts'), apiRoute);
-    // Update .env.example to include FUNCTIONS_BASE_URL
+    // Update .env.example to include BACKEND_FUNCTIONS_BASE_URL
     const envExamplePath = path.join(projectDir, '.env.example');
     let envExample = fs.readFileSync(envExamplePath, 'utf-8');
-    if (!envExample.includes('FUNCTIONS_BASE_URL')) {
+    if (!envExample.includes('BACKEND_FUNCTIONS_BASE_URL')) {
         envExample += `\n# Azure Functions Backend URL\nBACKEND_FUNCTIONS_BASE_URL=http://localhost:7071\n`;
         fs.writeFileSync(envExamplePath, envExample);
     }
     // Update .env.local
     const envLocalPath = path.join(projectDir, '.env.local');
     let envLocal = fs.readFileSync(envLocalPath, 'utf-8');
-    if (!envLocal.includes('FUNCTIONS_BASE_URL')) {
+    if (!envLocal.includes('BACKEND_FUNCTIONS_BASE_URL')) {
         envLocal += `\n# Azure Functions Backend URL (Local)\nBACKEND_FUNCTIONS_BASE_URL=http://localhost:7071\n`;
         fs.writeFileSync(envLocalPath, envLocal);
     }
@@ -985,7 +1614,7 @@ export default function Home() {
                 Create your first model with Zod and generate CRUD operations automatically.
               </p>
               <code className="block bg-gray-100 dark:bg-gray-900 p-4 rounded text-left text-sm">
-                ${pmCmd.dlx} swallowkit scaffold lib/models/your-model.ts
+                ${pmCmd.dlx} swallowkit scaffold shared/models/your-model.ts
               </code>
             </div>
           </section>
@@ -1021,13 +1650,29 @@ export const scaffoldConfig = {
     fs.writeFileSync(path.join(scaffoldConfigDir, 'scaffold-config.ts'), scaffoldConfigContent);
     console.log('✅ Scaffold config created\n');
 }
-function createReadme(projectDir, projectName, cicdChoice, azureConfig, pm) {
+function createReadme(projectDir, projectName, cicdChoice, azureConfig, pm, backendLanguage) {
     console.log('📝 Creating README.md...\n');
     const pmCmd = (0, package_manager_1.getCommands)(pm);
     const cosmosDbModeLabel = azureConfig.cosmosDbMode === 'freetier' ? 'Free Tier (1000 RU/s)' : 'Serverless';
     const cicdLabel = cicdChoice === 'github' ? 'GitHub Actions' : cicdChoice === 'azure' ? 'Azure Pipelines' : 'None';
     const vnetLabel = azureConfig.vnetOption === 'none' ? 'None (public endpoints)' :
         'Outbound VNet (Cosmos DB Private Endpoint)';
+    const backendLanguageLabel = getBackendLanguageLabel(backendLanguage);
+    const schemaBridgeDescription = backendLanguage === 'typescript'
+        ? 'Zod (shared between frontend and backend)'
+        : `Zod + OpenAPI export (Zod in shared/, native-generated ${backendLanguageLabel} schemas in functions/generated/)`;
+    const functionsTree = backendLanguage === 'typescript'
+        ? `│   └── src/\n│       └── greet.ts      # Sample function`
+        : backendLanguage === 'csharp'
+            ? `│   ├── Crud/\n│   │   └── GreetFunction.cs\n│   └── generated/       # Native-generated C# schema assets`
+            : `│   ├── blueprints/\n│   │   └── greet.py\n│   └── generated/       # Native-generated Python schema assets`;
+    const backendScaffoldNote = backendLanguage === 'typescript'
+        ? '- Azure Functions CRUD endpoints'
+        : `- Azure Functions ${backendLanguageLabel} CRUD handlers\n- OpenAPI export + native-generated ${backendLanguageLabel} schema assets`;
+    const pythonUvPaths = (0, python_uv_1.getProjectLocalUvPaths)(projectDir);
+    const pythonLocalDevNote = backendLanguage === 'python'
+        ? `\n**Python local dev note**: SwallowKit uses \`uv\` for Python backends and keeps the managed Python runtime under \`${path.relative(projectDir, pythonUvPaths.pythonInstallDir)}\`. Local Azure Functions runs from \`functions/.venv\`, schema generation uses \`functions/.codegen-venv\`, and \`swallowkit dev\` bootstraps a project-local \`uv\` binary automatically when needed. Keep \`functions/requirements.txt\` and \`functions/requirements.codegen.txt\` as the dependency sources of truth.\n`
+        : '';
     const readme = `# ${projectName}
 
 A full-stack application built with **SwallowKit** - Next.js on Azure Static Web Apps + Functions + Cosmos DB with Zod schema sharing.
@@ -1036,9 +1681,9 @@ A full-stack application built with **SwallowKit** - Next.js on Azure Static Web
 
 - **Frontend**: Next.js 15 (App Router), React, TypeScript, Tailwind CSS
 - **BFF (Backend for Frontend)**: Next.js API Routes
-- **Backend**: Azure Functions (TypeScript)
+- **Backend**: Azure Functions (${backendLanguageLabel})
 - **Database**: Azure Cosmos DB
-- **Schema Validation**: Zod (shared between frontend and backend)
+- **Schema Validation**: ${schemaBridgeDescription}
 - **Infrastructure**: Bicep (Infrastructure as Code)
 - **CI/CD**: ${cicdLabel}
 
@@ -1073,11 +1718,8 @@ ${projectName}/
 │   ├── api/               # BFF API routes (proxy to Functions)
 │   └── page.tsx           # Home page
 ├── functions/             # Azure Functions (backend)
-│   └── src/
-│       ├── models/        # Data models (copied from lib/models)
-│       └── hello.ts       # Sample function
+${functionsTree}
 ├── lib/
-│   ├── models/            # Shared Zod schemas
 │   └── api/               # API client utilities
 ├── infra/                 # Bicep infrastructure files
 │   ├── main.bicep
@@ -1095,18 +1737,18 @@ Define your data model with Zod schema:
 ${pmCmd.dlx} swallowkit create-model <model-name>
 \`\`\`
 
-This creates a model file in \`lib/models/<model-name>.ts\`. Edit it to define your schema.
+This creates a model file in \`shared/models/<model-name>.ts\`. Edit it to define your schema.
 
 ### 2. Generate CRUD Code
 
 Generate complete CRUD operations (Functions, API routes, UI):
 
 \`\`\`bash
-${pmCmd.dlx} swallowkit scaffold lib/models/<model-name>.ts
+${pmCmd.dlx} swallowkit scaffold shared/models/<model-name>.ts
 \`\`\`
 
 This generates:
-- Azure Functions CRUD endpoints
+${backendScaffoldNote}
 - Next.js BFF API routes
 - React UI components (list, detail, create, edit)
 - Navigation menu integration
@@ -1123,6 +1765,7 @@ This starts:
 - Cosmos DB Emulator check (must be running separately)
 
 **Note**: You need to start Cosmos DB Emulator manually before running \`swallowkit dev\`.
+${pythonLocalDevNote}
 
 ## ☁️ Deploy to Azure
 
@@ -1237,415 +1880,71 @@ This project was generated by SwallowKit. If you encounter any issues or have su
     fs.writeFileSync(path.join(projectDir, 'README.md'), readme);
     console.log('✅ README.md created\n');
 }
-function createAiAgentFiles(projectDir, projectName) {
+function createAiAgentFiles(projectDir, projectName, backendLanguage, pm) {
     console.log('🤖 Creating AI agent instruction files...\n');
-    // ── 1. AGENTS.md (Codex / generic agents) ──────────────────────────
-    const agentsMd = `# AGENTS.md
-
-This project was generated by **SwallowKit**.
-All coding agents **must** follow the architecture and conventions described below.
-
-## Architecture Overview
-
-This is a full-stack TypeScript application deployed on Azure with the following layers:
-
-\`\`\`
-Frontend (React / Next.js App Router)
-  ↓ fetch('/api/{model}', ...)
-BFF Layer (Next.js API Routes)
-  ↓ HTTP → Azure Functions
-Backend (Azure Functions with Cosmos DB bindings)
-  ↓
-Azure Cosmos DB (Document Database)
-\`\`\`
-
-### Project Structure
-
-\`\`\`
-${projectName}/
-├── app/                    # Next.js App Router
-│   ├── api/               # BFF API routes (proxy to Azure Functions)
-│   └── {model}/           # UI pages per model (list, detail, create, edit)
-├── functions/             # Azure Functions (backend)
-│   └── src/               # HTTP trigger handlers with Cosmos DB bindings
-├── shared/                # Shared workspace package
-│   ├── models/            # Zod schema definitions (single source of truth)
-│   └── index.ts           # Re-exports all models
-├── lib/
-│   └── api/               # API client utilities (backend.ts, call-function.ts)
-├── components/            # Shared React components
-├── infra/                 # Bicep infrastructure-as-code files
-│   ├── main.bicep
-│   └── modules/
-└── .github/workflows/     # CI/CD workflows (if configured)
-\`\`\`
-
-## Critical Design Principles
-
-### 1. Next.js API Routes Are Strictly a BFF (Backend for Frontend)
-
-- \`app/api/\` routes exist **only** to proxy requests to Azure Functions.
-- **Never** place business logic, database access, or direct Cosmos DB calls in Next.js API routes.
-- The BFF layer may validate input/output with Zod schemas before forwarding to Functions.
-- Use the \`callFunction\` helper (\`lib/api/call-function.ts\`) or the \`api\` client (\`lib/api/backend.ts\`) to call Azure Functions.
-
-Example BFF route pattern:
-
-\`\`\`typescript
-// app/api/{model}/route.ts
-import { callFunction } from '@/lib/api/call-function';
-import { ModelSchema } from '@${projectName}/shared';
-import { z } from 'zod/v4';
-
-export async function GET() {
-  return callFunction({
-    method: 'GET',
-    path: '/api/{model}',
-    responseSchema: z.array(ModelSchema),
-  });
+    const runCmd = pm === 'pnpm' ? 'pnpm' : 'npx';
+    (0, agent_instructions_1.writeAgentInstructionFiles)(projectDir, {
+        projectName,
+        backendLanguage,
+        packageManager: pm,
+    });
+    console.log('  ✅ AGENTS.md (canonical project contract)');
+    console.log('  ✅ CLAUDE.md (Claude Code adapter)');
+    console.log('  ✅ .github/copilot-instructions.md (GitHub Copilot adapter)');
+    console.log('  ✅ .github/instructions/ (path-specific instructions)');
+    fs.writeFileSync(path.join(projectDir, '.mcp.json'), buildSwallowKitMcpProjectConfigSource(pm));
+    console.log('  ✅ .mcp.json (project-scoped MCP bootstrap)');
+    (0, workflows_1.writeWorkflowDocs)(projectDir, runCmd);
+    console.log('  ✅ .swallowkit/workflows/ (agent-agnostic autonomous-loop runbooks)');
+    const skillPaths = (0, workflows_1.writeAgentSkills)(projectDir, runCmd);
+    console.log('  ✅ .github/skills/ (Agent Skills — agentskills.io open standard)');
+    for (const skillPath of skillPaths) {
+        console.log(`     - ${skillPath}`);
+    }
+    console.log('\n✅ AI agent files created\n');
 }
-
-export async function POST(request: NextRequest) {
-  const body = await request.json();
-  return callFunction({
-    method: 'POST',
-    path: '/api/{model}',
-    body,
-    inputSchema: ModelSchema.omit({ id: true, createdAt: true, updatedAt: true }),
-    responseSchema: ModelSchema,
-    successStatus: 201,
-  });
+function buildFunctionsHostKeyBicepExpression() {
+    return "listKeys('${resourceId('Microsoft.Web/sites', functionsAppName)}/host/default', '2023-12-01').functionKeys.default";
 }
-\`\`\`
-
-### 2. Zod Schemas Are the Single Source of Truth
-
-- All data models are defined **once** as Zod schemas in \`shared/models/\`.
-- TypeScript types are derived with \`z.infer<typeof Schema>\` — never define types separately.
-- The same schema is used in **all three layers**: frontend (validation), BFF (input/output validation), and Azure Functions (request/response validation + Cosmos DB documents).
-- The shared package (\`@${projectName}/shared\`) is consumed by both Next.js and Azure Functions as a workspace dependency.
-
-Model definition pattern:
-
-\`\`\`typescript
-// shared/models/{model}.ts
-import { z } from 'zod/v4';
-
-export const Todo = z.object({
-  id: z.string(),
-  name: z.string().min(1),
-  // ... your fields
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional(),
-});
-
-export type Todo = z.infer<typeof Todo>;
-export const displayName = 'Todo';
-\`\`\`
-
-Key rules:
-- Use the **Zod official pattern**: the schema constant and the TypeScript type share the same name.
-- \`id\`, \`createdAt\`, and \`updatedAt\` are auto-managed by the backend. Mark them as \`optional()\` in the schema.
-- Always re-export models from \`shared/index.ts\`.
-
-### 3. Azure Functions Own All Business Logic and Data Access
-
-- All CRUD operations and business logic live in \`functions/src/\`.
-- Use Azure Functions Cosmos DB **input/output bindings** (\`extraInputs\`/\`extraOutputs\`) for reads and writes.
-- Use the Cosmos DB SDK client directly **only** for delete operations (bindings do not support delete).
-- Validate all data against Zod schemas before writing to Cosmos DB.
-- The backend auto-generates \`id\` (UUID), \`createdAt\`, and \`updatedAt\` — never trust client-sent values for these fields.
-
-Azure Functions handler pattern:
-
-\`\`\`typescript
-// functions/src/{model}.ts
-import { app } from '@azure/functions';
-import { ModelSchema } from '@${projectName}/shared';
-
-const containerName = 'Models'; // PascalCase + 's'
-
-app.http('{model}-get-all', {
-  methods: ['GET'],
-  route: '{model}',
-  authLevel: 'anonymous',
-  extraInputs: [{ type: 'cosmosDB', name: 'cosmosInput', containerName, ... }],
-  handler: async (request, context) => {
-    const documents = context.extraInputs.get('cosmosInput');
-    const validated = z.array(ModelSchema).parse(documents);
-    return { status: 200, jsonBody: validated };
-  },
-});
-\`\`\`
-
-## Naming Conventions
-
-| Item | Convention | Example |
-|------|-----------|---------|
-| Model schema file | \`shared/models/{kebab-case}.ts\` | \`shared/models/todo.ts\` |
-| Schema/type name | PascalCase (same name for both) | \`export const Todo = z.object({...}); export type Todo = z.infer<typeof Todo>;\` |
-| Functions handler file | \`functions/src/{kebab-case}.ts\` | \`functions/src/todo.ts\` |
-| Functions handler name | \`{camelCase}-{operation}\` | \`todo-get-all\`, \`todo-create\` |
-| API route path | \`/api/{camelCase}\` | \`/api/todo\`, \`/api/todo/{id}\` |
-| BFF route file | \`app/api/{kebab-case}/route.ts\` | \`app/api/todo/route.ts\` |
-| BFF detail route | \`app/api/{kebab-case}/[id]/route.ts\` | \`app/api/todo/[id]/route.ts\` |
-| UI page directory | \`app/{kebab-case}/\` | \`app/todo/page.tsx\` |
-| React component | PascalCase | \`TodoForm.tsx\` |
-| Cosmos DB container | PascalCase + 's' | \`Todos\` |
-| Cosmos DB partition key | \`/id\` | Always \`/id\` |
-| Bicep container file | \`infra/containers/{kebab-case}-container.bicep\` | \`infra/containers/todo-container.bicep\` |
-
-## Adding New Models (SwallowKit CLI Skills)
-
-Use the SwallowKit CLI — do **not** manually create model files or CRUD boilerplate.
-
-### Skill: Create a new data model
-
-\`\`\`bash
-npx swallowkit create-model <name>
-# Multiple models at once:
-npx swallowkit create-model user post comment
-\`\`\`
-
-Creates \`shared/models/<name>.ts\` with a Zod schema template including \`id\`, \`createdAt\`, \`updatedAt\`.
-Edit the generated file to add your domain-specific fields, then run scaffold.
-
-### Skill: Generate full CRUD from a model
-
-\`\`\`bash
-npx swallowkit scaffold shared/models/<name>.ts
-\`\`\`
-
-Generates:
-- Azure Functions handlers (\`functions/src/<name>.ts\`)
-- BFF API routes (\`app/api/<name>/route.ts\`, \`app/api/<name>/[id]/route.ts\`)
-- UI pages (\`app/<name>/page.tsx\`, detail, create, edit pages)
-- Cosmos DB Bicep container config (\`infra/containers/<name>-container.bicep\`)
-
-### Skill: Start development servers
-
-\`\`\`bash
-npx swallowkit dev
-\`\`\`
-
-Runs Next.js (http://localhost:3000) and Azure Functions (http://localhost:7071) concurrently.
-Checks for Cosmos DB Emulator availability.
-
-### Skill: Provision Azure resources
-
-\`\`\`bash
-npx swallowkit provision --resource-group <name> --location <region>
-\`\`\`
-
-Deploys Bicep infrastructure: Static Web Apps, Functions, Cosmos DB, Storage, Managed Identity.
-
-### Typical workflow for "add a new feature/model"
-
-1. \`npx swallowkit create-model <name>\`
-2. Edit \`shared/models/<name>.ts\` — add fields
-3. \`npx swallowkit scaffold shared/models/<name>.ts\`
-4. \`npx swallowkit dev\` — verify at http://localhost:3000/<name>
-
-## Do NOT
-
-- **Do not** put business logic or database calls in \`app/api/\` routes. They are BFF only.
-- **Do not** define TypeScript interfaces/types separately from Zod schemas. Always derive types with \`z.infer<>\`.
-- **Do not** manually duplicate model definitions across layers. Use the shared package.
-- **Do not** manually create CRUD boilerplate. Use \`swallowkit scaffold\`.
-- **Do not** hardcode Cosmos DB connection strings. Use Managed Identity (\`CosmosDBConnection__accountEndpoint\`) in production and emulator settings locally.
-- **Do not** change the partition key strategy. All containers use \`/id\` as the partition key.
-
-## Technology Stack
-
-- **Frontend**: Next.js (App Router), React, TypeScript, Tailwind CSS
-- **BFF**: Next.js API Routes (proxy only)
-- **Backend**: Azure Functions (TypeScript, Node.js)
-- **Database**: Azure Cosmos DB (NoSQL)
-- **Schema**: Zod (shared across all layers via workspace package)
-- **Infrastructure**: Bicep (IaC)
-- **Hosting**: Azure Static Web Apps (frontend) + Azure Functions Flex Consumption (backend)
-- **Auth**: Azure Managed Identity (no connection strings in production)
-- **Monitoring**: Application Insights
-`;
-    fs.writeFileSync(path.join(projectDir, 'AGENTS.md'), agentsMd);
-    console.log('  ✅ AGENTS.md (Codex / generic agents)');
-    // ── 2. CLAUDE.md (Claude Code) ─────────────────────────────────────
-    const claudeMd = `# CLAUDE.md
-
-This file is for Claude Code. Read AGENTS.md in the project root for the full architecture, conventions, and rules.
-
-## Quick Reference
-
-- **Architecture**: Next.js (frontend) → BFF (API routes, proxy only) → Azure Functions (backend) → Cosmos DB
-- **Schema**: Zod schemas in \`shared/models/\` are the single source of truth. Never define types separately.
-- **BFF rule**: \`app/api/\` routes must ONLY proxy to Azure Functions via \`callFunction()\`. No business logic.
-- **Backend rule**: All business logic and Cosmos DB access lives in \`functions/src/\`.
-
-## SwallowKit CLI Commands
-
-| Task | Command |
-|------|---------|
-| Create model | \`npx swallowkit create-model <name>\` |
-| Generate CRUD | \`npx swallowkit scaffold shared/models/<name>.ts\` |
-| Dev servers | \`npx swallowkit dev\` |
-| Provision Azure | \`npx swallowkit provision --resource-group <rg> --location <region>\` |
-
-## Workflow: Add a new model
-
-1. \`npx swallowkit create-model <name>\`
-2. Edit \`shared/models/<name>.ts\` — add your fields
-3. \`npx swallowkit scaffold shared/models/<name>.ts\`
-4. \`npx swallowkit dev\` — verify at http://localhost:3000/<name>
-`;
-    fs.writeFileSync(path.join(projectDir, 'CLAUDE.md'), claudeMd);
-    console.log('  ✅ CLAUDE.md (Claude Code)');
-    // ── 3. .github/copilot-instructions.md (GitHub Copilot) ────────────
-    const ghDir = path.join(projectDir, '.github');
-    fs.mkdirSync(ghDir, { recursive: true });
-    const copilotInstructions = `# Copilot Instructions
-
-This project was generated by **SwallowKit**. See \`AGENTS.md\` in the project root for the full specification.
-
-## Architecture (3-layer)
-
-\`\`\`
-Frontend (Next.js App Router) → BFF (Next.js API Routes) → Backend (Azure Functions) → Cosmos DB
-\`\`\`
+function buildStaticWebAppConfigBicepSource() {
+    return `@description('Static Web App name')
+param staticWebAppName string
 
-## Key Rules
+@description('Functions App default hostname for backend API calls')
+param functionsDefaultHostname string
 
-1. **BFF is proxy only** — \`app/api/\` routes call Azure Functions via \`callFunction()\`. No business logic, no direct DB access.
-2. **Zod = single source of truth** — Models live in \`shared/models/\`. Types are derived with \`z.infer<>\`. Never define types separately.
-3. **Backend owns data** — All CRUD, business logic, and Cosmos DB access is in \`functions/src/\`.
-4. **Use the CLI** — Run \`npx swallowkit create-model <name>\` then \`npx swallowkit scaffold shared/models/<name>.ts\` to add models. Do not create boilerplate manually.
+@description('Functions App name used to resolve its host key after deployment')
+param functionsAppName string
 
-## Naming
+@description('Application Insights connection string for SWA')
+param appInsightsConnectionString string
 
-- Schema/type: PascalCase, same name for both (\`export const Todo = z.object({...}); export type Todo = z.infer<typeof Todo>;\`)
-- Files: kebab-case (\`shared/models/todo.ts\`, \`functions/src/todo.ts\`)
-- Cosmos DB containers: PascalCase + 's' (\`Todos\`), partition key always \`/id\`
+resource staticWebApp 'Microsoft.Web/staticSites@2023-01-01' existing = {
+  name: staticWebAppName
+}
 
-## Managed Fields
+resource staticWebAppConfig 'Microsoft.Web/staticSites/config@2023-01-01' = {
+  parent: staticWebApp
+  name: 'appsettings'
+  properties: {
+    APPLICATIONINSIGHTS_CONNECTION_STRING: appInsightsConnectionString
+    ApplicationInsightsAgent_EXTENSION_VERSION: '~3'
+    BACKEND_FUNCTIONS_BASE_URL: 'https://\${functionsDefaultHostname}'
+    BACKEND_FUNCTIONS_KEY: ${buildFunctionsHostKeyBicepExpression()}
+  }
+}
 
-\`id\`, \`createdAt\`, \`updatedAt\` are auto-managed by the backend. Define them as \`optional()\` in schemas. Never trust client-sent values.
-`;
-    fs.writeFileSync(path.join(ghDir, 'copilot-instructions.md'), copilotInstructions);
-    console.log('  ✅ .github/copilot-instructions.md (GitHub Copilot)');
-    // ── 4. .github/instructions/*.instructions.md (Copilot layer-specific) ──
-    const instructionsDir = path.join(ghDir, 'instructions');
-    fs.mkdirSync(instructionsDir, { recursive: true });
-    // 4a. shared/models — Zod schema layer
-    const sharedModelsInstructions = `---
-applyTo: "shared/models/**"
----
-
-# Shared Models — Zod Schema Rules
-
-Files in this directory are the **single source of truth** for data models across the entire application.
-
-## Rules
-
-- Define Zod schemas using \`zod/v4\` (\`import { z } from 'zod/v4'\`).
-- Use the **Zod official pattern**: the schema constant and the TypeScript type share the same name.
-  \`\`\`typescript
-  export const Todo = z.object({ ... });
-  export type Todo = z.infer<typeof Todo>;
-  \`\`\`
-- Always include \`id: z.string()\`, \`createdAt: z.string().optional()\`, \`updatedAt: z.string().optional()\`. These are managed by the backend.
-- Export a \`displayName\` string constant for UI display.
-- Re-export every model from \`shared/index.ts\`.
-- For relationships, use **nested schemas** (import and embed the related schema), not ID references.
-- After editing a model, run \`npx swallowkit scaffold shared/models/<name>.ts\` to regenerate CRUD code.
+output configName string = staticWebAppConfig.name
 `;
-    fs.writeFileSync(path.join(instructionsDir, 'shared-models.instructions.md'), sharedModelsInstructions);
-    // 4b. app/api — BFF layer
-    const bffInstructions = `---
-applyTo: "app/api/**"
----
-
-# BFF API Routes — Rules
-
-Files in \`app/api/\` are the **BFF (Backend for Frontend)** layer. They exist solely to proxy requests to Azure Functions.
-
-## Rules
-
-- **Never** put business logic, database access, or direct Cosmos DB calls here.
-- Use \`callFunction()\` from \`@/lib/api/call-function\` to forward requests to Azure Functions.
-- You may validate input/output with Zod schemas before forwarding.
-- Import schemas from \`@${projectName}/shared\`.
-
-## Pattern
-
-\`\`\`typescript
-import { callFunction } from '@/lib/api/call-function';
-import { ModelSchema } from '@${projectName}/shared';
-import { z } from 'zod/v4';
-
-export async function GET() {
-  return callFunction({
-    method: 'GET',
-    path: '/api/{model}',
-    responseSchema: z.array(ModelSchema),
-  });
 }
-\`\`\`
-`;
-    fs.writeFileSync(path.join(instructionsDir, 'bff-routes.instructions.md'), bffInstructions);
-    // 4c. functions — Azure Functions backend layer
-    const functionsInstructions = `---
-applyTo: "functions/**"
----
-
-# Azure Functions — Backend Rules
-
-Files in \`functions/src/\` contain all business logic and data access for this application.
-
-## Rules
-
-- Use Cosmos DB **input/output bindings** (\`extraInputs\`/\`extraOutputs\`) for reads and writes.
-- Use the Cosmos DB SDK client directly **only** for delete operations.
-- Validate all request data against Zod schemas from \`@${projectName}/shared\` before writing.
-- Auto-generate \`id\` (UUID), \`createdAt\`, and \`updatedAt\` on the backend. Never trust client-sent values.
-- Container names are PascalCase + 's' (e.g., \`Todos\`). Partition key is always \`/id\`.
-
-## Handler Pattern
-
-\`\`\`typescript
-import { app } from '@azure/functions';
-import { ModelSchema } from '@${projectName}/shared';
-
-app.http('{model}-get-all', {
-  methods: ['GET'],
-  route: '{model}',
-  authLevel: 'anonymous',
-  extraInputs: [cosmosInput],
-  handler: async (request, context) => {
-    const documents = context.extraInputs.get(cosmosInput);
-    const validated = z.array(ModelSchema).parse(documents);
-    return { status: 200, jsonBody: validated };
-  },
-});
-\`\`\`
-`;
-    fs.writeFileSync(path.join(instructionsDir, 'azure-functions.instructions.md'), functionsInstructions);
-    console.log('  ✅ .github/instructions/ (Copilot layer-specific instructions)');
-    console.log('     - shared-models.instructions.md');
-    console.log('     - bff-routes.instructions.md');
-    console.log('     - azure-functions.instructions.md');
-    console.log('\n✅ AI agent files created\n');
-    console.log('   Supported agents:');
-    console.log('   - OpenAI Codex          → AGENTS.md');
-    console.log('   - Claude Code           → CLAUDE.md (+ AGENTS.md)');
-    console.log('   - GitHub Copilot        → .github/copilot-instructions.md');
-    console.log('   - GitHub Copilot (edit) → .github/instructions/*.instructions.md');
-    console.log('');
-}
-async function createInfrastructure(projectDir, projectName, azureConfig) {
+async function createInfrastructure(projectDir, projectName, azureConfig, backendLanguage) {
     console.log('📦 Creating infrastructure files (Bicep)...\n');
     const infraDir = path.join(projectDir, 'infra');
     const modulesDir = path.join(infraDir, 'modules');
     fs.mkdirSync(modulesDir, { recursive: true });
     const enableVNet = azureConfig.vnetOption !== 'none';
+    const functionsRuntime = getFunctionsRuntimeConfig(backendLanguage);
+    const staticWebAppSku = getStaticWebAppSku(azureConfig.swaPlan);
     // main.bicep
     const mainBicep = `targetScope = 'resourceGroup'
 
@@ -1658,6 +1957,13 @@ param location string = resourceGroup().location
 @description('Location for Static Web App (must be explicitly provided)')
 param swaLocation string
 
+@description('Static Web Apps hosting plan')
+@allowed([
+  'Free'
+  'Standard'
+])
+param staticWebAppSku string = '${staticWebAppSku}'
+
 @description('Cosmos DB mode')
 @allowed(['freetier', 'serverless'])
 param cosmosDbMode string = '${azureConfig.cosmosDbMode}'
@@ -1700,7 +2006,7 @@ module staticWebApp 'modules/staticwebapp.bicep' = {
   params: {
     name: 'swa-\${projectName}'
     location: swaLocation
-    sku: 'Standard'
+    sku: staticWebAppSku
     appInsightsConnectionString: appInsightsSwa.outputs.connectionString
   }
 }
@@ -1741,35 +2047,30 @@ module cosmosPrivateEndpoint 'modules/private-endpoint-cosmos.bicep' = if (enabl
   params: {
     name: 'pe-cosmos-\${projectName}'
     location: location
-    cosmosAccountId: cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.id : cosmosDbServerless.outputs.id
-    cosmosAccountName: cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.accountName : cosmosDbServerless.outputs.accountName
-    subnetId: vnet.outputs.privateEndpointSubnetId
-    vnetId: vnet.outputs.id
+    cosmosAccountId: cosmosDbMode == 'freetier' ? cosmosDbFreeTier!.outputs.id : cosmosDbServerless!.outputs.id
+    cosmosAccountName: cosmosDbMode == 'freetier' ? cosmosDbFreeTier!.outputs.accountName : cosmosDbServerless!.outputs.accountName
+    subnetId: vnet!.outputs.privateEndpointSubnetId
+    vnetId: vnet!.outputs.id
   }
-  dependsOn: [
-    cosmosDbFreeTier
-    cosmosDbServerless
-    vnet
-  ]
 }
 
 // Azure Functions (Flex Consumption) - Deploy AFTER Cosmos DB
 module functionsFlex 'modules/functions-flex.bicep' = {
   name: 'functionsApp'
-  params: {
-    name: 'func-\${projectName}'
-    location: location
-    storageAccountName: 'stg\${uniqueString(resourceGroup().id, projectName)}'
-    appInsightsConnectionString: appInsightsFunctions.outputs.connectionString
-    swaDefaultHostname: staticWebApp.outputs.defaultHostname
-    cosmosDbEndpoint: cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.endpoint : cosmosDbServerless.outputs.endpoint
-    cosmosDbDatabaseName: cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.databaseName : cosmosDbServerless.outputs.databaseName
-    enableVNet: enableVNet
-    vnetSubnetId: enableVNet ? vnet.outputs.functionsSubnetId : ''
+    params: {
+      name: 'func-\${projectName}'
+      location: location
+      storageAccountName: 'stg\${uniqueString(resourceGroup().id, projectName)}'
+      appInsightsConnectionString: appInsightsFunctions.outputs.connectionString
+      swaDefaultHostname: staticWebApp.outputs.defaultHostname
+      cosmosDbEndpoint: cosmosDbMode == 'freetier' ? cosmosDbFreeTier!.outputs.endpoint : cosmosDbServerless!.outputs.endpoint
+      cosmosDbDatabaseName: cosmosDbMode == 'freetier' ? cosmosDbFreeTier!.outputs.databaseName : cosmosDbServerless!.outputs.databaseName
+      functionsRuntimeName: '${functionsRuntime.name}'
+      functionsRuntimeVersion: '${functionsRuntime.version}'
+      enableVNet: enableVNet
+      vnetSubnetId: enableVNet ? vnet!.outputs.functionsSubnetId : ''
   }
   dependsOn: [
-    cosmosDbFreeTier
-    cosmosDbServerless
     cosmosPrivateEndpoint
   ]
 }
@@ -1778,23 +2079,17 @@ module functionsFlex 'modules/functions-flex.bicep' = {
 module cosmosDbRoleAssignmentFreeTier 'modules/cosmosdb-role-assignment.bicep' = if (cosmosDbMode == 'freetier') {
   name: 'cosmosDbRoleAssignment'
   params: {
-    cosmosAccountName: cosmosDbFreeTier.outputs.accountName
+    cosmosAccountName: cosmosDbFreeTier!.outputs.accountName
     functionsPrincipalId: functionsFlex.outputs.principalId
   }
-  dependsOn: [
-    functionsFlex
-  ]
 }
 
 module cosmosDbRoleAssignmentServerless 'modules/cosmosdb-role-assignment.bicep' = if (cosmosDbMode == 'serverless') {
   name: 'cosmosDbRoleAssignment'
   params: {
-    cosmosAccountName: cosmosDbServerless.outputs.accountName
+    cosmosAccountName: cosmosDbServerless!.outputs.accountName
     functionsPrincipalId: functionsFlex.outputs.principalId
   }
-  dependsOn: [
-    functionsFlex
-  ]
 }
 
 // Update SWA config with Functions hostname (after Functions deployment)
@@ -1803,20 +2098,18 @@ module staticWebAppConfig 'modules/staticwebapp-config.bicep' = {
   params: {
     staticWebAppName: staticWebApp.outputs.name
     functionsDefaultHostname: functionsFlex.outputs.defaultHostname
+    functionsAppName: functionsFlex.outputs.name
     appInsightsConnectionString: appInsightsSwa.outputs.connectionString
   }
-  dependsOn: [
-    functionsFlex
-  ]
 }
 
 output staticWebAppName string = staticWebApp.outputs.name
 output staticWebAppUrl string = staticWebApp.outputs.defaultHostname
 output functionsAppName string = functionsFlex.outputs.name
 output functionsAppUrl string = functionsFlex.outputs.defaultHostname
-output cosmosDbAccountName string = cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.accountName : cosmosDbServerless.outputs.accountName
-output cosmosDbEndpoint string = cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.endpoint : cosmosDbServerless.outputs.endpoint
-output cosmosDatabaseName string = cosmosDbMode == 'freetier' ? cosmosDbFreeTier.outputs.databaseName : cosmosDbServerless.outputs.databaseName
+output cosmosDbAccountName string = cosmosDbMode == 'freetier' ? cosmosDbFreeTier!.outputs.accountName : cosmosDbServerless!.outputs.accountName
+output cosmosDbEndpoint string = cosmosDbMode == 'freetier' ? cosmosDbFreeTier!.outputs.endpoint : cosmosDbServerless!.outputs.endpoint
+output cosmosDatabaseName string = cosmosDbMode == 'freetier' ? cosmosDbFreeTier!.outputs.databaseName : cosmosDbServerless!.outputs.databaseName
 output logAnalyticsWorkspaceName string = logAnalytics.outputs.name
 output logAnalyticsWorkspaceId string = logAnalytics.outputs.id
 output appInsightsSwaName string = appInsightsSwa.outputs.name
@@ -1824,7 +2117,7 @@ output appInsightsSwaConnectionString string = appInsightsSwa.outputs.connection
 output appInsightsFunctionsName string = appInsightsFunctions.outputs.name
 output appInsightsFunctionsConnectionString string = appInsightsFunctions.outputs.connectionString
 output vnetEnabled bool = enableVNet
-output vnetName string = enableVNet ? vnet.outputs.name : ''
+output vnetName string = enableVNet ? vnet!.outputs.name : ''
 `;
     fs.writeFileSync(path.join(infraDir, 'main.bicep'), mainBicep);
     // main.parameters.json
@@ -1838,6 +2131,9 @@ output vnetName string = enableVNet ? vnet.outputs.name : ''
     "cosmosDbMode": {
       "value": "${azureConfig.cosmosDbMode}"
     },
+    "staticWebAppSku": {
+      "value": "${staticWebAppSku}"
+    },
     "enableVNet": {
       "value": ${enableVNet}
     }
@@ -1892,31 +2188,7 @@ output defaultHostname string = staticWebApp.properties.defaultHostname
 `;
     fs.writeFileSync(path.join(modulesDir, 'staticwebapp.bicep'), staticWebAppBicep);
     // modules/staticwebapp-config.bicep (for updating config after Functions deployment)
-    const staticWebAppConfigBicep = `@description('Static Web App name')
-param staticWebAppName string
-
-@description('Functions App default hostname for backend API calls')
-param functionsDefaultHostname string
-
-@description('Application Insights connection string for SWA')
-param appInsightsConnectionString string
-
-resource staticWebApp 'Microsoft.Web/staticSites@2023-01-01' existing = {
-  name: staticWebAppName
-}
-
-resource staticWebAppConfig 'Microsoft.Web/staticSites/config@2023-01-01' = {
-  parent: staticWebApp
-  name: 'appsettings'
-  properties: {
-    APPLICATIONINSIGHTS_CONNECTION_STRING: appInsightsConnectionString
-    ApplicationInsightsAgent_EXTENSION_VERSION: '~3'
-    BACKEND_FUNCTIONS_BASE_URL: 'https://\${functionsDefaultHostname}'
-  }
-}
-
-output configName string = staticWebAppConfig.name
-`;
+    const staticWebAppConfigBicep = buildStaticWebAppConfigBicepSource();
     fs.writeFileSync(path.join(modulesDir, 'staticwebapp-config.bicep'), staticWebAppConfigBicep);
     // modules/loganalytics.bicep (Shared Log Analytics Workspace)
     const logAnalyticsBicep = `@description('Log Analytics workspace name')
@@ -1996,6 +2268,12 @@ param enableVNet bool = false
 @description('VNet subnet ID for Functions (required if enableVNet is true)')
 param vnetSubnetId string = ''
 
+@description('Functions runtime name')
+param functionsRuntimeName string
+
+@description('Functions runtime version')
+param functionsRuntimeVersion string
+
 // Storage Account for Functions
 resource storageAccount 'Microsoft.Storage/storageAccounts@2023-01-01' = {
   name: storageAccountName
@@ -2066,8 +2344,8 @@ resource functionApp 'Microsoft.Web/sites@2023-12-01' = {
         instanceMemoryMB: 2048
       }
       runtime: {
-        name: 'node'
-        version: '22'
+        name: functionsRuntimeName
+        version: functionsRuntimeVersion
       }
     }
     siteConfig: {
@@ -2129,63 +2407,7 @@ output principalId string = functionApp.identity.principalId
 `;
     fs.writeFileSync(path.join(modulesDir, 'functions-flex.bicep'), functionsFlexBicep);
     // modules/cosmosdb-freetier.bicep (Free Tier)
-    const cosmosDbFreeTierBicep = `@description('Cosmos DB account name')
-param accountName string
-
-@description('Database name')
-param databaseName string
-
-@description('Location for Cosmos DB')
-param location string
-
-@description('Public network access')
-@allowed(['Enabled', 'Disabled'])
-param publicNetworkAccess string = 'Enabled'
-
-// Cosmos DB Account (Free Tier)
-resource cosmosAccount 'Microsoft.DocumentDB/databaseAccounts@2023-11-15' = {
-  name: accountName
-  location: location
-  kind: 'GlobalDocumentDB'
-  properties: {
-    databaseAccountOfferType: 'Standard'
-    enableAutomaticFailover: false
-    enableFreeTier: true
-    publicNetworkAccess: publicNetworkAccess
-    disableLocalAuth: true
-    consistencyPolicy: {
-      defaultConsistencyLevel: 'Session'
-    }
-    locations: [
-      {
-        locationName: location
-        failoverPriority: 0
-        isZoneRedundant: false
-      }
-    ]
-    disableKeyBasedMetadataWriteAccess: true
-  }
-}
-
-// Cosmos DB Database
-resource database 'Microsoft.DocumentDB/databaseAccounts/sqlDatabases@2023-11-15' = {
-  parent: cosmosAccount
-  name: databaseName
-  properties: {
-    resource: {
-      id: databaseName
-    }
-    options: {
-      throughput: 1000
-    }
-  }
-}
-
-output id string = cosmosAccount.id
-output accountName string = cosmosAccount.name
-output endpoint string = cosmosAccount.properties.documentEndpoint
-output databaseName string = database.name
-`;
+    const cosmosDbFreeTierBicep = buildCosmosDbFreeTierBicepSource();
     fs.writeFileSync(path.join(modulesDir, 'cosmosdb-freetier.bicep'), cosmosDbFreeTierBicep);
     // modules/cosmosdb-serverless.bicep (Serverless)
     const cosmosDbServerlessBicep = `@description('Cosmos DB account name')
@@ -2275,10 +2497,11 @@ resource roleAssignment 'Microsoft.DocumentDB/databaseAccounts/sqlRoleAssignment
 output roleAssignmentId string = roleAssignment.id
 `;
     fs.writeFileSync(path.join(modulesDir, 'cosmosdb-role-assignment.bicep'), cosmosDbRoleAssignmentBicep);
-    // VNet modules (only generate if VNet is enabled)
-    if (enableVNet) {
-        // modules/vnet.bicep
-        const vnetBicep = `@description('VNet name')
+    // Bicep resolves module files at compile time even when their deployment condition is false,
+    // so these definitions must always be generated. main.bicep still controls deployment with
+    // `if (enableVNet)`.
+    // modules/vnet.bicep
+    const vnetBicep = `@description('VNet name')
 param name string
 
 @description('Location for VNet')
@@ -2324,9 +2547,9 @@ output name string = vnet.name
 output functionsSubnetId string = vnet.properties.subnets[0].id
 output privateEndpointSubnetId string = vnet.properties.subnets[1].id
 `;
-        fs.writeFileSync(path.join(modulesDir, 'vnet.bicep'), vnetBicep);
-        // modules/private-endpoint-cosmos.bicep
-        const cosmosPrivateEndpointBicep = `@description('Private endpoint name')
+    fs.writeFileSync(path.join(modulesDir, 'vnet.bicep'), vnetBicep);
+    // modules/private-endpoint-cosmos.bicep
+    const cosmosPrivateEndpointBicep = `@description('Private endpoint name')
 param name string
 
 @description('Location')
@@ -2404,73 +2627,83 @@ resource privateDnsZoneGroup 'Microsoft.Network/privateEndpoints/privateDnsZoneG
 output privateEndpointId string = privateEndpoint.id
 output privateDnsZoneId string = privateDnsZone.id
 `;
-        fs.writeFileSync(path.join(modulesDir, 'private-endpoint-cosmos.bicep'), cosmosPrivateEndpointBicep);
-        console.log('✅ VNet modules created\n');
-    }
+    fs.writeFileSync(path.join(modulesDir, 'private-endpoint-cosmos.bicep'), cosmosPrivateEndpointBicep);
+    console.log('✅ VNet module definitions created\n');
     console.log('✅ Infrastructure files created\n');
 }
-async function createGitHubActionsWorkflows(projectDir, azureConfig, pm) {
-    console.log('📦 Creating GitHub Actions workflows...\n');
+function getGitHubFunctionsWorkflow(pm, backendLanguage, projectPm = pm) {
     const pmCmd = (0, package_manager_1.getCommands)(pm);
     const pnpmSetupStep = (0, package_manager_1.getCiSetupStep)(pm);
-    const workflowsDir = path.join(projectDir, '.github', 'workflows');
-    fs.mkdirSync(workflowsDir, { recursive: true });
-    // deploy-swa.yml
-    const swaWorkflow = `name: Deploy Static Web App
+    const npmWorkspaceNormalizationStep = getGitHubNpmWorkspaceNormalizationStep(pm, projectPm);
+    const commonSetup = `      - uses: actions/checkout@v4
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+${pnpmSetupStep ? `\n${pnpmSetupStep}\n` : ''}
+${npmWorkspaceNormalizationStep ? `\n${npmWorkspaceNormalizationStep}` : ''}
+      - name: Install dependencies
+        run: |
+          ${(0, package_manager_1.getCiInstallCommand)(pm, projectPm)}
+      
+      - name: Build shared package
+        run: |
+          ${pmCmd.runFilter('shared')} build
+`;
+    if (backendLanguage === 'typescript') {
+        return `name: Deploy Azure Functions
 
 on:
   push:
     branches:
       - main
     paths:
-      - 'app/**'
-      - 'components/**'
-      - 'lib/**'
+      - 'functions/**'
       - 'shared/**'
-      - 'public/**'
-      - 'package.json'
-      - 'next.config.js'
-      - 'next.config.ts'
-  workflow_dispatch:
   pull_request:
     branches:
       - main
     paths:
-      - 'app/**'
-      - 'components/**'
-      - 'lib/**'
+      - 'functions/**'
       - 'shared/**'
-      - 'public/**'
-      - 'package.json'
-      - 'next.config.js'
-      - 'next.config.ts'
+  workflow_dispatch:
 
 jobs:
   build-and-deploy:
     runs-on: ubuntu-latest
-    name: Build and Deploy Static Web App
+    name: Build and Deploy Functions
     
     steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
+${commonSetup}      - name: Build Functions
+        run: |
+          ${pmCmd.runFilter('functions')} build
       
-      - name: Deploy to Azure Static Web Apps
+      - name: Prepare functions for deployment
+        run: |
+          SHARED_PKG_NAME=$(node -p "require('./shared/package.json').name")
+          mkdir -p /tmp/fn-deps
+          node -e "const p=JSON.parse(require('fs').readFileSync('./functions/package.json','utf8'));Object.keys(p.dependencies).filter(k=>k.endsWith('/shared')).forEach(k=>delete p.dependencies[k]);require('fs').writeFileSync('/tmp/fn-deps/package.json',JSON.stringify(p,null,2));"
+          cd /tmp/fn-deps && ${pmCmd.installProd} && cd -
+          rm -rf ./functions/node_modules
+          mv /tmp/fn-deps/node_modules ./functions/node_modules
+          SHARED_DEST="./functions/node_modules/$SHARED_PKG_NAME"
+          mkdir -p "$SHARED_DEST"
+          cp -r ./shared/dist "$SHARED_DEST/dist"
+          cp ./shared/package.json "$SHARED_DEST/package.json"
+      
+      - name: Deploy to Azure Functions
         if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
-        uses: Azure/static-web-apps-deploy@v1
+        uses: Azure/functions-action@v1
         with:
-          azure_static_web_apps_api_token: \${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
-          repo_token: \${{ secrets.GITHUB_TOKEN }}
-          action: 'upload'
-          app_location: '/'
-          api_location: ''
-          output_location: ''
-        env:
-          NEXT_TURBOPACK_EXPERIMENTAL_USE_SYSTEM_TLS_CERTS: '1'
+          app-name: \${{ secrets.AZURE_FUNCTIONAPP_NAME }}
+          package: './functions'
+          publish-profile: \${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
+          sku: flexconsumption
 `;
-    fs.writeFileSync(path.join(workflowsDir, 'deploy-swa.yml'), swaWorkflow);
-    // deploy-functions.yml
-    const functionsWorkflow = `name: Deploy Azure Functions
+    }
+    if (backendLanguage === 'csharp') {
+        return `name: Deploy Azure Functions
 
 on:
   push:
@@ -2493,37 +2726,57 @@ jobs:
     name: Build and Deploy Functions
     
     steps:
-      - uses: actions/checkout@v4
-      
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
+${commonSetup}      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
         with:
-          node-version: '22'
-${pnpmSetupStep ? `\n${pnpmSetupStep}\n` : ''}
-      - name: Install dependencies
-        run: |
-          ${pmCmd.ci}
-      
-      - name: Build shared package
-        run: |
-          ${pmCmd.runFilter('shared')} build
-      
-      - name: Build Functions
+          dotnet-version: '10.0.x'
+
+      - name: Publish Functions
         run: |
-          ${pmCmd.runFilter('functions')} build
+          dotnet publish ./functions -c Release -o ./functions/publish
       
-      - name: Prepare functions for deployment
+      - name: Deploy to Azure Functions
+        if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
+        uses: Azure/functions-action@v1
+        with:
+          app-name: \${{ secrets.AZURE_FUNCTIONAPP_NAME }}
+          package: './functions/publish'
+          publish-profile: \${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
+          sku: flexconsumption
+`;
+    }
+    return `name: Deploy Azure Functions
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'functions/**'
+      - 'shared/**'
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'functions/**'
+      - 'shared/**'
+  workflow_dispatch:
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    name: Build and Deploy Functions
+    
+    steps:
+${commonSetup}      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install Functions dependencies
         run: |
-          SHARED_PKG_NAME=$(node -p "require('./shared/package.json').name")
-          mkdir -p /tmp/fn-deps
-          node -e "const p=JSON.parse(require('fs').readFileSync('./functions/package.json','utf8'));Object.keys(p.dependencies).filter(k=>k.endsWith('/shared')).forEach(k=>delete p.dependencies[k]);require('fs').writeFileSync('/tmp/fn-deps/package.json',JSON.stringify(p,null,2));"
-          cd /tmp/fn-deps && ${pmCmd.installProd} && cd -
-          rm -rf ./functions/node_modules
-          mv /tmp/fn-deps/node_modules ./functions/node_modules
-          SHARED_DEST="./functions/node_modules/$SHARED_PKG_NAME"
-          mkdir -p "$SHARED_DEST"
-          cp -r ./shared/dist "$SHARED_DEST/dist"
-          cp ./shared/package.json "$SHARED_DEST/package.json"
+          python -m pip install --upgrade pip
+          python -m pip install -r ./functions/requirements.txt --target "./functions/.python_packages/lib/site-packages"
       
       - name: Deploy to Azure Functions
         if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
@@ -2534,29 +2787,34 @@ ${pnpmSetupStep ? `\n${pnpmSetupStep}\n` : ''}
           publish-profile: \${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
           sku: flexconsumption
 `;
-    fs.writeFileSync(path.join(workflowsDir, 'deploy-functions.yml'), functionsWorkflow);
-    console.log('✅ GitHub Actions workflows created\n');
 }
-async function createAzurePipelines(projectDir, pm) {
-    console.log('📦 Creating Azure Pipelines...\n');
+function getAzureFunctionsPipeline(pm, backendLanguage, projectPm = pm) {
     const pmCmd = (0, package_manager_1.getCommands)(pm);
     const azPipelinesSetup = (0, package_manager_1.getAzurePipelinesSetup)(pm);
-    const pipelinesDir = path.join(projectDir, 'pipelines');
-    fs.mkdirSync(pipelinesDir, { recursive: true });
-    // swa.yml
-    const swaPipeline = `trigger:
+    const npmWorkspaceNormalizationStep = getAzurePipelinesNpmWorkspaceNormalizationStep(pm, projectPm);
+    const commonSetup = `  - task: NodeTool@0
+    inputs:
+      versionSpec: '22.x'
+    displayName: 'Install Node.js'
+${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
+${npmWorkspaceNormalizationStep ? `\n${npmWorkspaceNormalizationStep}\n` : ''}
+  - script: |
+      ${(0, package_manager_1.getCiInstallCommand)(pm, projectPm)}
+    displayName: 'Install workspace dependencies'
+
+  - script: |
+      ${pmCmd.runFilter('shared')} build
+    displayName: 'Build shared package'
+`;
+    if (backendLanguage === 'typescript') {
+        return `trigger:
   branches:
     include:
       - main
   paths:
     include:
-      - app/**
-      - components/**
-      - lib/**
+      - functions/**
       - shared/**
-      - public/**
-      - package.json
-      - next.config.js
 
 pr:
   branches:
@@ -2564,13 +2822,8 @@ pr:
       - main
   paths:
     include:
-      - app/**
-      - components/**
-      - lib/**
+      - functions/**
       - shared/**
-      - public/**
-      - package.json
-      - next.config.js
 
 pool:
   vmImage: 'ubuntu-latest'
@@ -2579,33 +2832,51 @@ variables:
   - group: azure-deployment
 
 steps:
-  - task: NodeTool@0
-    inputs:
-      versionSpec: '22.x'
-    displayName: 'Install Node.js'
-${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
-  - script: |
-      ${pmCmd.ci}
-    displayName: 'Install dependencies'
+${commonSetup}  - script: |
+      ${pmCmd.runFilter('functions')} build
+    displayName: 'Build Functions'
 
   - script: |
-      ${pmCmd.run} build
-    env:
-      NODE_ENV: production
-    displayName: 'Build Next.js app'
+      SHARED_PKG_NAME=$(node -p "require('./shared/package.json').name")
+      mkdir -p /tmp/fn-deps
+      node -e "const p=JSON.parse(require('fs').readFileSync('./functions/package.json','utf8'));Object.keys(p.dependencies).filter(k=>k.endsWith('/shared')).forEach(k=>delete p.dependencies[k]);require('fs').writeFileSync('/tmp/fn-deps/package.json',JSON.stringify(p,null,2));"
+      cd /tmp/fn-deps && ${pmCmd.installProd} && cd -
+      rm -rf ./functions/node_modules
+      mv /tmp/fn-deps/node_modules ./functions/node_modules
+      SHARED_DEST="./functions/node_modules/$SHARED_PKG_NAME"
+      mkdir -p "$SHARED_DEST"
+      cp -r ./shared/dist "$SHARED_DEST/dist"
+      cp ./shared/package.json "$SHARED_DEST/package.json"
+    displayName: 'Prepare functions for deployment'
 
-  - task: AzureStaticWebApp@0
+  - task: ArchiveFiles@2
     condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
     inputs:
-      app_location: '.'
-      output_location: '.next/standalone'
-      skip_app_build: true
-      azure_static_web_apps_api_token: $(AZURE_STATIC_WEB_APPS_API_TOKEN)
-    displayName: 'Deploy to Azure Static Web Apps'
+      rootFolderOrFile: '$(System.DefaultWorkingDirectory)/functions'
+      includeRootFolder: false
+      archiveType: 'zip'
+      archiveFile: '$(Build.ArtifactStagingDirectory)/functions.zip'
+    displayName: 'Archive Functions'
+
+  - task: PublishBuildArtifacts@1
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      PathtoPublish: '$(Build.ArtifactStagingDirectory)/functions.zip'
+      ArtifactName: 'functions'
+    displayName: 'Publish Functions artifact'
+
+  - task: AzureFunctionApp@2
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      azureSubscription: '$(AZURE_SUBSCRIPTION)'
+      appType: 'functionAppLinux'
+      appName: '$(AZURE_FUNCTIONAPP_NAME)'
+      package: '$(Build.ArtifactStagingDirectory)/functions.zip'
+    displayName: 'Deploy to Azure Functions'
 `;
-    fs.writeFileSync(path.join(pipelinesDir, 'swa.yml'), swaPipeline);
-    // functions.yml
-    const functionsPipeline = `trigger:
+    }
+    if (backendLanguage === 'csharp') {
+        return `trigger:
   branches:
     include:
       - main
@@ -2630,35 +2901,68 @@ variables:
   - group: azure-deployment
 
 steps:
-  - task: NodeTool@0
+${commonSetup}  - task: UseDotNet@2
     inputs:
-      versionSpec: '22.x'
-    displayName: 'Install Node.js'
-${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
-  - script: |
-      ${pmCmd.ci}
-    displayName: 'Install workspace dependencies'
+      version: '10.0.x'
+    displayName: 'Install .NET SDK'
 
   - script: |
-      ${pmCmd.runFilter('shared')} build
-    displayName: 'Build shared package'
+      dotnet publish ./functions -c Release -o ./functions/publish
+    displayName: 'Publish Functions'
 
-  - script: |
-      ${pmCmd.runFilter('functions')} build
-    displayName: 'Build Functions'
+  - task: ArchiveFiles@2
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      rootFolderOrFile: '$(System.DefaultWorkingDirectory)/functions/publish'
+      includeRootFolder: false
+      archiveType: 'zip'
+      archiveFile: '$(Build.ArtifactStagingDirectory)/functions.zip'
+    displayName: 'Archive Functions'
+
+  - task: AzureFunctionApp@2
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      azureSubscription: '$(AZURE_SUBSCRIPTION)'
+      appType: 'functionAppLinux'
+      appName: '$(AZURE_FUNCTIONAPP_NAME)'
+      package: '$(Build.ArtifactStagingDirectory)/functions.zip'
+    displayName: 'Deploy to Azure Functions'
+`;
+    }
+    return `trigger:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - functions/**
+      - shared/**
+
+pr:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - functions/**
+      - shared/**
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  - group: azure-deployment
+
+steps:
+${commonSetup}  - task: UsePythonVersion@0
+    inputs:
+      versionSpec: '3.11'
+    displayName: 'Install Python'
 
   - script: |
-      SHARED_PKG_NAME=$(node -p "require('./shared/package.json').name")
-      mkdir -p /tmp/fn-deps
-      node -e "const p=JSON.parse(require('fs').readFileSync('./functions/package.json','utf8'));Object.keys(p.dependencies).filter(k=>k.endsWith('/shared')).forEach(k=>delete p.dependencies[k]);require('fs').writeFileSync('/tmp/fn-deps/package.json',JSON.stringify(p,null,2));"
-      cd /tmp/fn-deps && ${pmCmd.installProd} && cd -
-      rm -rf ./functions/node_modules
-      mv /tmp/fn-deps/node_modules ./functions/node_modules
-      SHARED_DEST="./functions/node_modules/$SHARED_PKG_NAME"
-      mkdir -p "$SHARED_DEST"
-      cp -r ./shared/dist "$SHARED_DEST/dist"
-      cp ./shared/package.json "$SHARED_DEST/package.json"
-    displayName: 'Prepare functions for deployment'
+      python -m pip install --upgrade pip
+      python -m pip install -r ./functions/requirements.txt --target "./functions/.python_packages/lib/site-packages"
+    displayName: 'Install Functions dependencies'
 
   - task: ArchiveFiles@2
     condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
@@ -2669,13 +2973,6 @@ ${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
       archiveFile: '$(Build.ArtifactStagingDirectory)/functions.zip'
     displayName: 'Archive Functions'
 
-  - task: PublishBuildArtifacts@1
-    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
-    inputs:
-      PathtoPublish: '$(Build.ArtifactStagingDirectory)/functions.zip'
-      ArtifactName: 'functions'
-    displayName: 'Publish Functions artifact'
-
   - task: AzureFunctionApp@2
     condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
     inputs:
@@ -2685,6 +2982,264 @@ ${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
       package: '$(Build.ArtifactStagingDirectory)/functions.zip'
     displayName: 'Deploy to Azure Functions'
 `;
+}
+function buildAzureSwaPipeline(pm, projectPm = pm) {
+    const pmCmd = (0, package_manager_1.getCommands)(pm);
+    const azPipelinesSetup = (0, package_manager_1.getAzurePipelinesSetup)(pm);
+    const npmWorkspaceNormalizationStep = getAzurePipelinesNpmWorkspaceNormalizationStep(pm, projectPm);
+    return `trigger:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - app/**
+      - components/**
+      - lib/**
+      - shared/**
+      - public/**
+      - package.json
+      - next.config.js
+
+pr:
+  branches:
+    include:
+      - main
+  paths:
+    include:
+      - app/**
+      - components/**
+      - lib/**
+      - shared/**
+      - public/**
+      - package.json
+      - next.config.js
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+variables:
+  - group: azure-deployment
+
+steps:
+  - task: NodeTool@0
+    inputs:
+      versionSpec: '22.x'
+    displayName: 'Install Node.js'
+${azPipelinesSetup ? `\n${azPipelinesSetup}\n` : ''}
+${npmWorkspaceNormalizationStep ? `\n${npmWorkspaceNormalizationStep}\n` : ''}
+  - script: |
+      ${(0, package_manager_1.getCiInstallCommand)(pm, projectPm)}
+    displayName: 'Install dependencies'
+
+  - script: |
+      ${pmCmd.run} build
+    env:
+      NODE_ENV: production
+    displayName: 'Build Next.js app'
+
+  - task: AzureStaticWebApp@0
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    inputs:
+      app_location: '.'
+      output_location: '.next/standalone'
+      skip_app_build: true
+      azure_static_web_apps_api_token: $(AZURE_STATIC_WEB_APPS_API_TOKEN)
+    displayName: 'Deploy to Azure Static Web Apps'
+`;
+}
+function getAzurePipelinesNpmWorkspaceNormalizationStep(pm, projectPm) {
+    if (pm !== 'npm' || projectPm !== 'pnpm') {
+        return '';
+    }
+    return `  - script: |
+      node <<'NODE'
+      const fs = require('fs');
+
+      function readJson(path) {
+        return JSON.parse(fs.readFileSync(path, 'utf8'));
+      }
+
+      function writeJson(path, value) {
+        fs.writeFileSync(path, JSON.stringify(value, null, 2) + '\\n');
+      }
+
+      const sharedPackagePath = 'shared/package.json';
+      const sharedPackageName = fs.existsSync(sharedPackagePath) ? readJson(sharedPackagePath).name : undefined;
+
+      function replaceSharedWorkspaceDep(pkg, replacement) {
+        for (const section of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+          if (!pkg[section]) continue;
+
+          for (const [name, version] of Object.entries(pkg[section])) {
+            if (typeof version === 'string' && version.startsWith('workspace:') && (name === sharedPackageName || name.endsWith('/shared'))) {
+              pkg[section][name] = replacement;
+            }
+          }
+        }
+      }
+
+      const root = readJson('package.json');
+      root.workspaces = ['shared', 'functions'];
+      replaceSharedWorkspaceDep(root, 'file:shared');
+      root.scripts = root.scripts || {};
+      root.scripts.build = ${JSON.stringify((0, package_manager_1.getBuildScript)('npm'))};
+      writeJson('package.json', root);
+
+      if (fs.existsSync('functions/package.json')) {
+        const functionsPkg = readJson('functions/package.json');
+        replaceSharedWorkspaceDep(functionsPkg, 'file:../shared');
+        if (functionsPkg.scripts && functionsPkg.scripts.prestart) {
+          functionsPkg.scripts.prestart = 'npm run build';
+        }
+        writeJson('functions/package.json', functionsPkg);
+      }
+      NODE
+
+      npm install --package-lock-only --ignore-scripts
+    displayName: 'Normalize pnpm workspace for npm CI'`;
+}
+function getGitHubNpmWorkspaceNormalizationStep(pm, projectPm) {
+    if (pm !== 'npm' || projectPm !== 'pnpm') {
+        return '';
+    }
+    return `      - name: Normalize pnpm workspace for npm CI
+        shell: bash
+        run: |
+          node <<'NODE'
+          const fs = require('fs');
+
+          function readJson(path) {
+            return JSON.parse(fs.readFileSync(path, 'utf8'));
+          }
+
+          function writeJson(path, value) {
+            fs.writeFileSync(path, JSON.stringify(value, null, 2) + '\\n');
+          }
+
+          const sharedPackagePath = 'shared/package.json';
+          const sharedPackageName = fs.existsSync(sharedPackagePath) ? readJson(sharedPackagePath).name : undefined;
+
+          function replaceSharedWorkspaceDep(pkg, replacement) {
+            for (const section of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+              if (!pkg[section]) continue;
+
+              for (const [name, version] of Object.entries(pkg[section])) {
+                if (typeof version === 'string' && version.startsWith('workspace:') && (name === sharedPackageName || name.endsWith('/shared'))) {
+                  pkg[section][name] = replacement;
+                }
+              }
+            }
+          }
+
+          const root = readJson('package.json');
+          root.workspaces = ['shared', 'functions'];
+          replaceSharedWorkspaceDep(root, 'file:shared');
+          root.scripts = root.scripts || {};
+          root.scripts.build = ${JSON.stringify((0, package_manager_1.getBuildScript)('npm'))};
+          writeJson('package.json', root);
+
+          if (fs.existsSync('functions/package.json')) {
+            const functionsPkg = readJson('functions/package.json');
+            replaceSharedWorkspaceDep(functionsPkg, 'file:../shared');
+            if (functionsPkg.scripts && functionsPkg.scripts.prestart) {
+              functionsPkg.scripts.prestart = 'npm run build';
+            }
+            writeJson('functions/package.json', functionsPkg);
+          }
+          NODE
+
+          npm install --package-lock-only --ignore-scripts
+`;
+}
+async function createGitHubActionsWorkflows(projectDir, azureConfig, pm, backendLanguage) {
+    console.log('📦 Creating GitHub Actions workflows...\n');
+    const workflowsDir = path.join(projectDir, '.github', 'workflows');
+    fs.mkdirSync(workflowsDir, { recursive: true });
+    const actionsPm = 'npm';
+    const swaWorkflow = buildGitHubSwaWorkflow(actionsPm, pm);
+    fs.writeFileSync(path.join(workflowsDir, 'deploy-swa.yml'), swaWorkflow);
+    // deploy-functions.yml
+    const functionsWorkflow = getGitHubFunctionsWorkflow(actionsPm, backendLanguage, pm);
+    fs.writeFileSync(path.join(workflowsDir, 'deploy-functions.yml'), functionsWorkflow);
+    console.log('✅ GitHub Actions workflows created\n');
+}
+function buildGitHubSwaWorkflow(pm, projectPm = pm) {
+    const npmWorkspaceNormalizationStep = getGitHubNpmWorkspaceNormalizationStep(pm, projectPm);
+    return `name: Deploy Static Web App
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'app/**'
+      - 'components/**'
+      - 'lib/**'
+      - 'shared/**'
+      - 'public/**'
+      - 'package.json'
+      - 'next.config.js'
+      - 'next.config.ts'
+  workflow_dispatch:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'app/**'
+      - 'components/**'
+      - 'lib/**'
+      - 'shared/**'
+      - 'public/**'
+      - 'package.json'
+      - 'next.config.js'
+      - 'next.config.ts'
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    name: Build and Deploy Static Web App
+    
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+${(0, package_manager_1.getCiSetupStep)(pm) ? `\n${(0, package_manager_1.getCiSetupStep)(pm)}\n` : ''}
+${npmWorkspaceNormalizationStep ? `\n${npmWorkspaceNormalizationStep}` : ''}
+      - name: Install and build app
+        run: |
+          ${(0, package_manager_1.getSwaAppBuildCommand)(pm, projectPm)}
+      
+      - name: Deploy to Azure Static Web Apps
+        if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
+        uses: Azure/static-web-apps-deploy@v1
+        with:
+          azure_static_web_apps_api_token: \${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
+          repo_token: \${{ secrets.GITHUB_TOKEN }}
+          action: 'upload'
+          app_location: '/'
+          api_location: ''
+          output_location: ''
+          app_build_command: '${(0, package_manager_1.getSwaAppBuildCommand)(pm, projectPm)}'
+        env:
+          NEXT_TURBOPACK_EXPERIMENTAL_USE_SYSTEM_TLS_CERTS: '1'
+`;
+}
+async function createAzurePipelines(projectDir, pm, backendLanguage) {
+    console.log('📦 Creating Azure Pipelines...\n');
+    const pipelinesPm = 'npm';
+    const pipelinesDir = path.join(projectDir, 'pipelines');
+    fs.mkdirSync(pipelinesDir, { recursive: true });
+    // swa.yml
+    const swaPipeline = buildAzureSwaPipeline(pipelinesPm, pm);
+    fs.writeFileSync(path.join(pipelinesDir, 'swa.yml'), swaPipeline);
+    // functions.yml
+    const functionsPipeline = getAzureFunctionsPipeline(pipelinesPm, backendLanguage, pm);
     fs.writeFileSync(path.join(pipelinesDir, 'functions.yml'), functionsPipeline);
     console.log('✅ Azure Pipelines created\n');
 }