@meadow-studio/platform 0.0.0-stage → 0.1.0

package/dist/cli/commands.js

@@ -0,0 +1,1062 @@
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { createProjectConfig, readProjectConfig, validateProjectConfig, writeProjectConfig, } from './config.js';
+import { generatedFiles, meadowAgentSection, MEADOW_AGENT_SECTION_END, MEADOW_AGENT_SECTION_START, TOOLCHAIN, } from './templates.js';
+import { addLocalData, addNotifications, JEEP_SQLITE_PACKAGE_VERSION, LOCAL_DATA_PACKAGE_VERSION, LOCAL_NOTIFICATIONS_PACKAGE_VERSION, SQL_JS_PACKAGE_VERSION, } from './recipes.js';
+import { syncProject } from './sync.js';
+import { MEADOW_WEBSITE_MARKER, websiteConfig, websiteFiles } from './website.js';
+export const SYSTEM_COMMAND_RUNNER = Object.freeze({
+    run(command, args, directory) {
+        const result = spawnSync(command, args, spawnOptions(directory, 'inherit'));
+        if (result.error)
+            throw result.error;
+        if (result.status !== 0) {
+            throw new Error(`${command} ${args.join(' ')} exited with status ${result.status ?? 'unknown'}.`);
+        }
+    },
+    succeeds(command, args, directory) {
+        const result = spawnSync(command, args, spawnOptions(directory, 'ignore'));
+        return !result.error && result.status === 0;
+    },
+});
+export function createProject(options, runner = SYSTEM_COMMAND_RUNNER) {
+    const config = createProjectConfig(options.answers);
+    const target = resolve(options.directory, config.app.slug);
+    if (existsSync(target))
+        throw new Error(`Target already exists: ${target}`);
+    mkdirSync(options.directory, { recursive: true });
+    const scratch = mkdtempSync(join(options.directory, `.${config.app.slug}.meadow-`));
+    let completed = false;
+    try {
+        writeGeneratedProject(scratch, generatedFiles(config, options.platformVersion, options.platformSpec));
+        if (options.install) {
+            runner.run('npm', ['install'], scratch);
+            runner.run('npm', ['run', 'format'], scratch);
+            runner.run('npm', ['run', 'build:device'], scratch);
+            for (const platform of config.app.platforms) {
+                runner.run(localBinary(scratch, 'cap'), ['add', platform], scratch);
+            }
+            const syncResult = syncProject(scratch);
+            if (!syncResult.valid)
+                throw new Error('Generated project could not be synchronized.');
+            runner.run('npm', ['run', 'check'], scratch);
+            if (options.visualBaselines) {
+                runner.run(localBinary(scratch, 'playwright'), ['install', 'chromium'], scratch);
+                runner.run('npm', ['run', 'test:visual:update'], scratch);
+            }
+        }
+        if (options.git)
+            initializeGit(scratch, config, runner);
+        renameSync(scratch, target);
+        completed = true;
+        if (options.github)
+            createGithubRepository(target, config, options.github, runner);
+        return target;
+    }
+    finally {
+        if (!completed && existsSync(scratch))
+            rmSync(scratch, { recursive: true, force: true });
+    }
+}
+export function isCleanGitRepository(directory) {
+    const root = resolve(directory);
+    return existsSync(root) && statSync(root).isDirectory() &&
+        existsSync(resolve(root, '.git')) &&
+        readdirSync(root).every((entry) => entry === '.git');
+}
+export function initCleanRepository(options, runner = SYSTEM_COMMAND_RUNNER) {
+    const root = resolve(options.directory);
+    if (!isCleanGitRepository(root)) {
+        throw new Error('Clean-repository init requires an existing Git checkout containing only .git.');
+    }
+    const config = createProjectConfig(options.answers);
+    const files = generatedFiles(config, options.platformVersion, options.platformSpec);
+    const actions = [...files.keys()].map((target) => ({
+        kind: 'create', target, detail: 'Create the Meadow app and companion website in this repository.',
+    }));
+    if (options.install)
+        actions.push({ kind: 'run', target: 'npm install and project checks', detail: 'Install and validate the generated app.' });
+    if (options.dryRun)
+        return { config, actions, diagnostics: [], changed: true };
+    const stagingParent = mkdtempSync(join(dirname(root), '.meadow-init-'));
+    try {
+        const staged = createProject({
+            directory: stagingParent,
+            answers: options.answers,
+            platformVersion: options.platformVersion,
+            platformSpec: options.platformSpec,
+            install: options.install,
+            git: false,
+            visualBaselines: options.visualBaselines,
+        }, runner);
+        for (const entry of readdirSync(staged)) {
+            renameSync(resolve(staged, entry), resolve(root, entry));
+        }
+    }
+    finally {
+        rmSync(stagingParent, { recursive: true, force: true });
+    }
+    return { config, actions, diagnostics: doctor(root), changed: true };
+}
+export function writeGeneratedProject(directory, files) {
+    for (const [relativePath, contents] of files) {
+        const path = resolve(directory, relativePath);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, contents);
+    }
+}
+export function inspectExistingProject(directory = process.cwd()) {
+    const root = resolve(directory);
+    if (!existsSync(root) || !statSync(root).isDirectory()) {
+        throw new Error(`Project directory does not exist: ${root}`);
+    }
+    const packageJson = readPackageJson(root);
+    if (!existsSync(resolve(root, 'angular.json'))) {
+        throw new Error('meadow init currently supports Angular projects; angular.json is missing.');
+    }
+    if (!findCapacitorConfig(root)) {
+        throw new Error('meadow init currently supports Capacitor projects; capacitor.config.ts or capacitor.config.json is missing.');
+    }
+    const dependencies = packageDependencies(packageJson);
+    const angularVersion = dependencyVersion(dependencies, '@angular/core', 'Angular');
+    const capacitorVersion = dependencyVersion(dependencies, '@capacitor/core', 'Capacitor');
+    requireSupportedMajor(angularVersion, 22, 'Angular');
+    requireSupportedMajor(capacitorVersion, 8, 'Capacitor');
+    const existingConfig = existsSync(resolve(root, 'meadow.config.json'))
+        ? readProjectConfig(root)
+        : undefined;
+    const packageName = typeof packageJson.name === 'string' ? packageJson.name : '';
+    const packageVersion = semanticVersion(packageJson.version) ?? '0.1.0';
+    const capacitorSource = readCapacitorConfig(root);
+    const inferredName = existingConfig?.app.name ??
+        capacitorStringValue(capacitorSource, 'appName') ??
+        titleCase(packageName.replace(/^@[^/]+\//, '')) ??
+        'Meadow App';
+    const inferredSlug = existingConfig?.app.slug ?? slugFromPackageName(packageName, inferredName);
+    const inferredId = existingConfig?.app.identifiers.android ??
+        capacitorStringValue(capacitorSource, 'appId') ??
+        `app.meadow.${inferredSlug.replaceAll('-', '')}`;
+    const revenuecat = existingConfig?.services.revenuecat.enabled ??
+        Object.keys(dependencies).some((name) => name.includes('revenuecat'));
+    const supabase = existingConfig?.services.supabase.enabled ?? dependencies['@supabase/supabase-js'] !== undefined;
+    const warnings = [];
+    if (angularVersion !== TOOLCHAIN.angular) {
+        warnings.push(`Angular ${angularVersion} is supported by major version but differs from Meadow's ${TOOLCHAIN.angular} pin; meadow doctor will report it.`);
+    }
+    if (capacitorVersion !== TOOLCHAIN.capacitor) {
+        warnings.push(`Capacitor ${capacitorVersion} is supported by major version but differs from Meadow's ${TOOLCHAIN.capacitor} pin; meadow doctor will report it.`);
+    }
+    const ionic = Object.keys(dependencies).filter((name) => name.startsWith('@ionic/'));
+    if (ionic.length) {
+        warnings.push(`Ionic remains app-owned and will be preserved (${ionic.join(', ')}).`);
+    }
+    return {
+        directory: root,
+        answers: {
+            name: inferredName,
+            slug: inferredSlug,
+            id: inferredId,
+            description: existingConfig?.app.description,
+            supportEmail: existingConfig?.links.supportEmail,
+            supportUrl: existingConfig?.links.supportUrl,
+            privacyUrl: existingConfig?.links.privacyUrl,
+            termsUrl: existingConfig?.links.termsUrl,
+            websiteUrl: existingConfig?.links.websiteUrl,
+            platforms: existingConfig?.app.platforms,
+            orientation: existingConfig?.app.orientation ?? 'any',
+            devices: existingConfig?.app.devices ?? ['phone', 'tablet'],
+            revenuecat,
+            monetizationMode: existingConfig?.services.revenuecat.mode ??
+                (revenuecat ? 'subscription-and-lifetime' : 'none'),
+            supabase,
+        },
+        angularVersion,
+        capacitorVersion,
+        packageVersion,
+        alreadyInitialized: existingConfig !== undefined,
+        warnings,
+    };
+}
+export function initProject(options, runner = SYSTEM_COMMAND_RUNNER) {
+    const inspection = inspectExistingProject(options.directory);
+    const root = inspection.directory;
+    const existingConfig = existsSync(resolve(root, 'meadow.config.json'))
+        ? readProjectConfig(root)
+        : undefined;
+    const requestedWebsiteUrl = options.answers.websiteBaseDomain
+        ? createProjectConfig(options.answers).links.websiteUrl
+        : undefined;
+    const config = existingConfig
+        ? requestedWebsiteUrl && !existingConfig.links.websiteUrl
+            ? validateProjectConfig({
+                ...existingConfig,
+                links: { ...existingConfig.links, websiteUrl: requestedWebsiteUrl },
+            })
+            : existingConfig
+        : initializedConfig(createProjectConfig(options.answers), root, inspection.packageVersion);
+    const packageJson = readPackageJson(root);
+    const writes = new Map();
+    const actions = [];
+    if (!existingConfig || config !== existingConfig) {
+        scheduleWrite(writes, actions, 'meadow.config.json', `${JSON.stringify(config, null, 2)}\n`, root, 'Create or update validated Meadow project configuration.');
+    }
+    else {
+        actions.push({
+            kind: 'preserve',
+            target: 'meadow.config.json',
+            detail: 'Keep the existing valid Meadow project configuration.',
+        });
+    }
+    const websiteRoot = resolve(root, 'website');
+    const meadowWebsite = !existsSync(websiteRoot) || existsSync(resolve(root, MEADOW_WEBSITE_MARKER));
+    if (!existsSync(websiteRoot)) {
+        for (const [path, contents] of websiteFiles(config)) {
+            scheduleWrite(writes, actions, path, contents, root, 'Create the companion website project.');
+        }
+    }
+    else if (existsSync(resolve(root, MEADOW_WEBSITE_MARKER))) {
+        scheduleWrite(writes, actions, 'website/site.config.json', websiteConfig(config), root, 'Synchronize companion website metadata from meadow.config.json.');
+    }
+    else {
+        actions.push({
+            kind: 'preserve',
+            target: 'website/',
+            detail: 'Keep the existing app-owned website project.',
+        });
+    }
+    const requestedPlatformSpec = options.platformSpec ??
+        options.platformVersion;
+    const packageUpdate = initializedPackageJson(packageJson, config, requestedPlatformSpec, options.platformSpec !== undefined, meadowWebsite);
+    scheduleWrite(writes, actions, 'package.json', `${JSON.stringify(packageUpdate, null, 2)}\n`, root, 'Add the pinned Meadow dependency, shared provider dependencies, and non-conflicting Meadow scripts.');
+    const agentPath = resolve(root, 'AGENTS.md');
+    const existingAgents = existsSync(agentPath) ? readFileSync(agentPath, 'utf8') : '';
+    scheduleWrite(writes, actions, 'AGENTS.md', mergeManagedSection(existingAgents, meadowAgentSection(config), MEADOW_AGENT_SECTION_START, MEADOW_AGENT_SECTION_END, `# ${config.app.name} working context`), root, 'Add or refresh the managed Meadow agent guidance without replacing app-owned instructions.');
+    const ignoreBlock = `# meadow-platform:start\n/.env.meadow.local\n/.build\n/website/dist\n/android/.gradle\n/android/build\n/android/app/build\n/ios/App/DerivedData\n/playwright-report\n/test-results\n*.jks\n*.keystore\n*.p12\n*.mobileprovision\n*.xcarchive\n# meadow-platform:end`;
+    const gitignorePath = resolve(root, '.gitignore');
+    const existingGitignore = existsSync(gitignorePath) ? readFileSync(gitignorePath, 'utf8') : '';
+    scheduleWrite(writes, actions, '.gitignore', mergeManagedSection(existingGitignore, ignoreBlock, '# meadow-platform:start', '# meadow-platform:end'), root, 'Add Meadow-managed local configuration, build output, and signing exclusions.');
+    if (!existsSync(resolve(root, '.nvmrc'))) {
+        scheduleWrite(writes, actions, '.nvmrc', `${TOOLCHAIN.node}\n`, root, 'Pin the supported Node runtime.');
+    }
+    else {
+        actions.push({ kind: 'preserve', target: '.nvmrc', detail: 'Keep the existing Node version file.' });
+    }
+    const envBlock = environmentExampleSection(config);
+    if (envBlock) {
+        const envPath = resolve(root, '.env.example');
+        const existingEnv = existsSync(envPath) ? readFileSync(envPath, 'utf8') : '';
+        scheduleWrite(writes, actions, '.env.example', mergeManagedSection(existingEnv, envBlock, '# meadow-platform:start', '# meadow-platform:end'), root, 'Document app-owned public provider configuration names without adding credentials.');
+    }
+    if (options.install && writes.has('package.json')) {
+        actions.push({ kind: 'run', target: 'npm install', detail: 'Install the updated dependency set.' });
+    }
+    if (!options.dryRun) {
+        writeScheduledFiles(root, writes);
+        if (options.install && writes.has('package.json'))
+            runner.run('npm', ['install'], root);
+    }
+    return {
+        config,
+        actions,
+        diagnostics: options.dryRun ? [] : doctor(root),
+        changed: writes.size > 0,
+    };
+}
+export function configureIntegration(integration, options, runner = SYSTEM_COMMAND_RUNNER) {
+    const directory = resolve(options.directory);
+    const config = readProjectConfig(directory);
+    switch (integration) {
+        case 'firebase':
+            return configureFirebase(config, directory, options.values, runner);
+        case 'revenuecat':
+            return configureRevenueCat(config, directory, options.values, runner);
+        case 'supabase':
+            return configureSupabase(config, directory, options.values);
+        case 'assets':
+            return configureAssets(config, directory, options.values, runner);
+        case 'signing':
+            return configureSigning(directory);
+        case 'store':
+            return configureStore(config, directory, options.values);
+        case 'github':
+            createGithubRepository(directory, config, {
+                owner: textValue(options.values, 'owner', false),
+                visibility: visibilityValue(options.values.visibility),
+            }, runner);
+            return ['GitHub repository created and main pushed.'];
+        default:
+            throw new Error('Configure target must be firebase, revenuecat, supabase, assets, signing, store, or github.');
+    }
+}
+export function addCapability(capability, options, runner = SYSTEM_COMMAND_RUNNER) {
+    switch (capability) {
+        case 'local-data':
+            return addLocalData(options.directory, runner);
+        case 'notifications':
+            return addNotifications(options.directory, runner);
+        default:
+            throw new Error('Add target must be local-data or notifications.');
+    }
+}
+export function doctor(directory = process.cwd()) {
+    const root = resolve(directory);
+    const diagnostics = [];
+    let config;
+    try {
+        config = readProjectConfig(root);
+        diagnostics.push(pass('config', 'meadow.config.json is valid.'));
+    }
+    catch (error) {
+        diagnostics.push(failure('config', errorMessage(error)));
+        return diagnostics;
+    }
+    const major = Number(process.versions.node.split('.')[0]);
+    const minor = Number(process.versions.node.split('.')[1]);
+    diagnostics.push(major === 24 && minor >= 15
+        ? pass('node', `Node ${process.versions.node} satisfies the Meadow toolchain.`)
+        : failure('node', `Node 24.15 or newer within Node 24 is required; found ${process.versions.node}.`));
+    const packagePath = resolve(root, 'package.json');
+    if (!existsSync(packagePath)) {
+        diagnostics.push(failure('package', 'package.json is missing.'));
+    }
+    else {
+        try {
+            const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+            const allDependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            diagnostics.push(allDependencies['@angular/core'] === TOOLCHAIN.angular
+                ? pass('angular', `Angular ${TOOLCHAIN.angular} is pinned.`)
+                : failure('angular', `@angular/core must be pinned to ${TOOLCHAIN.angular}.`));
+            diagnostics.push(allDependencies['@capacitor/core'] === TOOLCHAIN.capacitor
+                ? pass('capacitor', `Capacitor ${TOOLCHAIN.capacitor} is pinned.`)
+                : failure('capacitor', `@capacitor/core must be pinned to ${TOOLCHAIN.capacitor}.`));
+            if (config.services.localData.enabled) {
+                for (const [name, version] of [
+                    ['@capacitor-community/sqlite', LOCAL_DATA_PACKAGE_VERSION],
+                    ['jeep-sqlite', JEEP_SQLITE_PACKAGE_VERSION],
+                    ['sql.js', SQL_JS_PACKAGE_VERSION],
+                ]) {
+                    diagnostics.push(allDependencies[name] === version
+                        ? pass(`local-data:dependency:${name}`, `${name} ${version} is pinned.`)
+                        : failure(`local-data:dependency:${name}`, `${name} must be pinned to ${version}.`));
+                }
+            }
+            if (config.services.notifications.enabled) {
+                diagnostics.push(allDependencies['@capacitor/local-notifications'] ===
+                    LOCAL_NOTIFICATIONS_PACKAGE_VERSION
+                    ? pass('notifications:dependency', `@capacitor/local-notifications ${LOCAL_NOTIFICATIONS_PACKAGE_VERSION} is pinned.`)
+                    : failure('notifications:dependency', `@capacitor/local-notifications must be pinned to ${LOCAL_NOTIFICATIONS_PACKAGE_VERSION}.`));
+            }
+            if (config.services.firebase.enabled) {
+                for (const [name, version] of [
+                    ['@capacitor-firebase/analytics', TOOLCHAIN.capacitorFirebase],
+                    ['@capacitor-firebase/crashlytics', TOOLCHAIN.capacitorFirebase],
+                    ['firebase', TOOLCHAIN.firebase],
+                ]) {
+                    diagnostics.push(allDependencies[name] === version
+                        ? pass(`firebase:dependency:${name}`, `${name} ${version} is pinned.`)
+                        : failure(`firebase:dependency:${name}`, `${name} must be pinned to ${version}.`));
+                }
+            }
+            if (config.services.revenuecat.enabled) {
+                diagnostics.push(allDependencies['@revenuecat/purchases-capacitor'] === TOOLCHAIN.revenuecat
+                    ? pass('revenuecat:dependency', `@revenuecat/purchases-capacitor ${TOOLCHAIN.revenuecat} is pinned.`)
+                    : failure('revenuecat:dependency', `@revenuecat/purchases-capacitor must be pinned to ${TOOLCHAIN.revenuecat}.`));
+            }
+            diagnostics.push(allDependencies.protractor
+                ? failure('stack:protractor', 'Protractor is end-of-life; use the generated Playwright setup.')
+                : pass('stack:protractor', 'No Protractor dependency is present.'));
+            const ionic = Object.keys(allDependencies).filter((name) => name.startsWith('@ionic/'));
+            diagnostics.push(ionic.length
+                ? warning('stack:ionic', `Ionic is app-owned (${ionic.join(', ')}) and must not be imported by @meadow-studio/platform.`)
+                : pass('stack:ionic', 'The application does not use Ionic.'));
+            const requiredScripts = [
+                'check',
+                ...(existsSync(resolve(root, MEADOW_WEBSITE_MARKER)) ? ['website:check'] : []),
+                'sync:check',
+                'test:unit',
+                'test:visual',
+                'build:web',
+                'services:config',
+                ...(config.app.platforms.includes('android') ? ['build:android:ci'] : []),
+                ...(config.app.platforms.includes('ios') ? ['build:ios:ci'] : []),
+            ];
+            for (const script of requiredScripts) {
+                if (!packageJson.scripts?.[script]) {
+                    diagnostics.push(failure(`script:${script}`, `Required npm script ${script} is missing.`));
+                }
+            }
+        }
+        catch (error) {
+            diagnostics.push(failure('package', `package.json is invalid: ${errorMessage(error)}`));
+        }
+    }
+    for (const path of [
+        '.github/workflows/ci.yml',
+        'playwright.config.ts',
+        'e2e/visual/app.visual.spec.ts',
+        'docs/RELEASE_CHECKLIST.md',
+    ]) {
+        diagnostics.push(existsSync(resolve(root, path)) ? pass(`file:${path}`, `${path} exists.`) : failure(`file:${path}`, `${path} is missing.`));
+    }
+    if (existsSync(resolve(root, MEADOW_WEBSITE_MARKER))) {
+        for (const path of [
+            'website/package.json',
+            'website/site.config.json',
+            'website/src/index.html',
+            'website/src/support/index.html',
+            'website/src/privacy/index.html',
+            'website/src/terms/index.html',
+        ]) {
+            diagnostics.push(existsSync(resolve(root, path))
+                ? pass(`website:${path}`, `${path} exists.`)
+                : failure(`website:${path}`, `${path} is missing.`));
+        }
+    }
+    else {
+        diagnostics.push(existsSync(resolve(root, 'website'))
+            ? pass('website', 'An app-owned website project exists.')
+            : warning('website', 'The companion website is missing; run meadow init to add it.'));
+    }
+    if (config.services.localData.enabled) {
+        for (const path of [
+            'src/app/data/local-data/local-data.migrations.ts',
+            'src/app/data/local-data/local-database.ts',
+            'src/app/data/local-data/local-document.store.ts',
+            'public/assets/sql-wasm.wasm',
+        ]) {
+            diagnostics.push(existsSync(resolve(root, path))
+                ? pass(`local-data:file:${path}`, `${path} exists.`)
+                : failure(`local-data:file:${path}`, `${path} is missing.`));
+        }
+        const migrationsPath = resolve(root, 'src/app/data/local-data/local-data.migrations.ts');
+        if (existsSync(migrationsPath)) {
+            const versions = [...readFileSync(migrationsPath, 'utf8').matchAll(/toVersion:\s*(\d+)/g)].map((match) => Number(match[1]));
+            const generatedVersion = versions.length ? Math.max(...versions) : 0;
+            diagnostics.push(generatedVersion === config.services.localData.databaseVersion
+                ? pass('local-data:version', `Local-data migration version ${generatedVersion} matches meadow.config.json.`)
+                : failure('local-data:version', `Local-data migrations end at ${generatedVersion}, but meadow.config.json records ${config.services.localData.databaseVersion}.`));
+        }
+        diagnostics.push(existsSync(resolve(root, 'src/app/data/local-data/.meadow-recipe-pending'))
+            ? failure('local-data:pending', 'The local-data recipe is still marked pending; rerun meadow add local-data.')
+            : pass('local-data:pending', 'The local-data recipe completed.'));
+        const androidManifest = resolve(root, 'android/app/src/main/AndroidManifest.xml');
+        if (existsSync(androidManifest)) {
+            const manifest = readFileSync(androidManifest, 'utf8');
+            diagnostics.push(manifest.includes('android:dataExtractionRules="@xml/data_extraction_rules"') &&
+                manifest.includes('android:allowBackup="false"')
+                ? pass('local-data:android-backup', 'Android local-data backup exclusions are configured.')
+                : failure('local-data:android-backup', 'Android local-data backup exclusions are missing.'));
+        }
+    }
+    if (config.services.notifications.enabled) {
+        const androidRoot = resolve(root, 'android');
+        if (config.app.platforms.includes('android') && existsSync(androidRoot)) {
+            diagnostics.push(filesContainText(root, ['android/capacitor.settings.gradle', 'android/app/capacitor.build.gradle'], 'capacitor-local-notifications')
+                ? pass('notifications:android-native', 'Android local-notifications plugin is synchronized.')
+                : failure('notifications:android-native', 'Android local-notifications plugin is not synchronized; rerun meadow add notifications.'));
+        }
+        const iosRoot = resolve(root, 'ios');
+        if (config.app.platforms.includes('ios') && existsSync(iosRoot)) {
+            diagnostics.push(filesContainText(root, ['ios/App/CapApp-SPM/Package.swift', 'ios/App/Podfile.lock'], 'CapacitorLocalNotifications')
+                ? pass('notifications:ios-native', 'iOS local-notifications plugin is synchronized.')
+                : failure('notifications:ios-native', 'iOS local-notifications plugin is not synchronized; rerun meadow add notifications.'));
+        }
+    }
+    for (const platform of config.app.platforms) {
+        diagnostics.push(existsSync(resolve(root, platform))
+            ? pass(`native:${platform}`, `${platform} project exists.`)
+            : warning(`native:${platform}`, `${platform} project is not generated yet; run npm run native:init.`));
+    }
+    if (config.services.firebase.enabled) {
+        if (config.app.platforms.includes('android') && existsSync(resolve(root, 'android'))) {
+            const googleServices = resolve(root, 'android/app/google-services.json');
+            diagnostics.push(existsSync(googleServices)
+                ? pass('firebase:android-config', 'Android Firebase configuration exists.')
+                : warning('firebase:android-config', 'android/app/google-services.json is missing; run meadow configure firebase.'));
+            const manifestPath = resolve(root, 'android/app/src/main/AndroidManifest.xml');
+            const projectGradlePath = resolve(root, 'android/build.gradle');
+            const appGradlePath = resolve(root, 'android/app/build.gradle');
+            if (existsSync(manifestPath) && existsSync(projectGradlePath) && existsSync(appGradlePath)) {
+                const manifest = readFileSync(manifestPath, 'utf8');
+                const projectGradle = readFileSync(projectGradlePath, 'utf8');
+                const appGradle = readFileSync(appGradlePath, 'utf8');
+                const optInDefaults = manifest.includes('firebase_analytics_collection_enabled') &&
+                    manifest.includes('firebase_crashlytics_collection_enabled');
+                const configuredPlugins = projectGradle.includes('com.google.gms:google-services') &&
+                    projectGradle.includes('com.google.firebase:firebase-crashlytics-gradle') &&
+                    appGradle.includes("apply plugin: 'com.google.gms.google-services'") &&
+                    appGradle.includes("apply plugin: 'com.google.firebase.crashlytics'");
+                diagnostics.push(optInDefaults && (!config.services.firebase.configured || configuredPlugins)
+                    ? pass('firebase:android-native', 'Android Firebase plugins and opt-in defaults are configured.')
+                    : failure('firebase:android-native', 'Android Firebase build plugins or opt-in collection defaults are missing; run meadow sync.'));
+            }
+        }
+        if (config.app.platforms.includes('ios') && existsSync(resolve(root, 'ios'))) {
+            const googleServiceInfo = resolve(root, 'ios/App/App/GoogleService-Info.plist');
+            diagnostics.push(existsSync(googleServiceInfo)
+                ? pass('firebase:ios-config', 'iOS Firebase configuration exists.')
+                : warning('firebase:ios-config', 'ios/App/App/GoogleService-Info.plist is missing; run meadow configure firebase.'));
+            const infoPath = resolve(root, 'ios/App/App/Info.plist');
+            const projectPath = resolve(root, 'ios/App/App.xcodeproj/project.pbxproj');
+            if (existsSync(infoPath) && existsSync(projectPath)) {
+                const info = readFileSync(infoPath, 'utf8');
+                const project = readFileSync(projectPath, 'utf8');
+                const bundledFirebaseConfig = !config.services.firebase.configured ||
+                    (project.includes('GoogleService-Info.plist') &&
+                        project.includes('GoogleService-Info.plist in Resources'));
+                diagnostics.push(info.includes('FIREBASE_ANALYTICS_COLLECTION_ENABLED') &&
+                    info.includes('FirebaseCrashlyticsCollectionEnabled') &&
+                    bundledFirebaseConfig
+                    ? pass('firebase:ios-native', 'iOS Firebase configuration resource and opt-in defaults are configured.')
+                    : failure('firebase:ios-native', 'iOS Firebase configuration resource or opt-in collection defaults are missing; run meadow sync.'));
+            }
+        }
+    }
+    if (config.services.revenuecat.enabled) {
+        const environment = readLocalEnvironment(root);
+        for (const platform of config.app.platforms) {
+            const variable = platform === 'ios'
+                ? 'MEADOW_REVENUECAT_IOS_API_KEY'
+                : 'MEADOW_REVENUECAT_ANDROID_API_KEY';
+            const value = process.env[variable] ?? environment[variable];
+            diagnostics.push(!config.services.revenuecat.configured
+                ? warning(`revenuecat:${platform}-key`, `RevenueCat is not configured; run meadow configure revenuecat.`)
+                : isRevenueCatPublicKey(value, platform)
+                    ? pass(`revenuecat:${platform}-key`, `${platform} RevenueCat public SDK key is available.`)
+                    : failure(`revenuecat:${platform}-key`, `${variable} is missing or is not a ${platform} public SDK key.`));
+        }
+        diagnostics.push(config.services.revenuecat.configured &&
+            Boolean(config.services.revenuecat.entitlementId) &&
+            Boolean(config.services.revenuecat.offeringId)
+            ? pass('revenuecat:catalog', 'RevenueCat offering and entitlement identifiers are configured.')
+            : config.services.revenuecat.configured
+                ? failure('revenuecat:catalog', 'RevenueCat offering or entitlement identifier is missing; rerun meadow configure revenuecat.')
+                : warning('revenuecat:catalog', 'RevenueCat catalog identifiers are not configured.'));
+    }
+    const screenshots = resolve(root, 'e2e/visual/__screenshots__');
+    diagnostics.push(existsSync(screenshots) && containsFile(screenshots, '.png')
+        ? pass('visual-baselines', 'Visual baselines exist.')
+        : warning('visual-baselines', 'Visual baselines are missing; run npm run test:visual:update in the CI-compatible environment.'));
+    try {
+        const sync = syncProject(root, true);
+        diagnostics.push(sync.valid
+            ? pass('sync', 'Generated project files match meadow.config.json.')
+            : failure('sync', 'Generated project files have drifted from meadow.config.json; run meadow sync and review the changes.'));
+    }
+    catch (error) {
+        diagnostics.push(failure('sync', `Could not check generated files: ${errorMessage(error)}`));
+    }
+    for (const [service, state] of Object.entries(config.services)) {
+        if (state.enabled && !state.configured) {
+            diagnostics.push(warning(`service:${service}`, `${service} is enabled but has not been configured.`));
+        }
+        else {
+            diagnostics.push(pass(`service:${service}`, `${service} configuration state is consistent.`));
+        }
+    }
+    return diagnostics;
+}
+export function releaseCheck(platform, directory = process.cwd(), runner = SYSTEM_COMMAND_RUNNER) {
+    const diagnostics = doctor(directory);
+    const config = readProjectConfig(directory);
+    if (platform !== 'all' && !config.app.platforms.includes(platform)) {
+        return [
+            ...diagnostics,
+            failure('release:platform', `${platform} is not enabled in meadow.config.json.`),
+        ];
+    }
+    const promoted = diagnostics.map((item) => item.level === 'warning' &&
+        (item.id === 'visual-baselines' ||
+            item.id.startsWith('native:') ||
+            item.id.startsWith('service:'))
+        ? failure(item.id, item.message)
+        : item);
+    if (config.release.channel === 'production') {
+        for (const [label, value] of [
+            ['support email', config.links.supportEmail],
+            ['website URL', config.links.websiteUrl],
+            ['privacy URL', config.links.privacyUrl],
+            ['terms URL', config.links.termsUrl],
+        ]) {
+            if (!value)
+                promoted.push(failure(`release:${label}`, `${label} is required for production.`));
+        }
+    }
+    if (promoted.some((item) => item.level === 'failure'))
+        return promoted;
+    runner.run('npm', ['run', 'check'], directory);
+    runner.run('npm', ['run', 'test:visual'], directory);
+    if ((platform === 'android' || platform === 'all') && config.app.platforms.includes('android')) {
+        runner.run('npm', ['run', 'build:android:ci'], directory);
+    }
+    if ((platform === 'ios' || platform === 'all') && config.app.platforms.includes('ios')) {
+        runner.run('npm', ['run', 'build:ios:ci'], directory);
+    }
+    return [...promoted, pass('release-check', `Release checks passed for ${platform}.`)];
+}
+export function setApplicationVersion(requested, channel, directory = process.cwd()) {
+    const root = resolve(directory);
+    const config = readProjectConfig(root);
+    const version = nextVersion(config.release.version, requested);
+    const releaseChannel = channel ?? config.release.channel;
+    if (!['development', 'test', 'production'].includes(releaseChannel)) {
+        throw new Error('Release channel must be development, test, or production.');
+    }
+    const next = {
+        ...config,
+        release: {
+            version,
+            build: config.release.build + 1,
+            channel: releaseChannel,
+        },
+    };
+    writeProjectConfig(next, root);
+    const sync = syncProject(root);
+    if (!sync.valid) {
+        throw new Error('Application version changed, but generated files could not be synchronized.');
+    }
+    return next;
+}
+export function nextVersion(current, requested) {
+    if (/^\d+\.\d+\.\d+$/.test(requested))
+        return requested;
+    if (!['major', 'minor', 'patch'].includes(requested)) {
+        throw new Error('Version must be major, minor, patch, or x.y.z.');
+    }
+    const [major, minor, patch] = current.split('.').map(Number);
+    if (requested === 'major')
+        return `${major + 1}.0.0`;
+    if (requested === 'minor')
+        return `${major}.${minor + 1}.0`;
+    return `${major}.${minor}.${patch + 1}`;
+}
+function configureFirebase(config, directory, values, runner) {
+    const configuredPlatforms = [];
+    if (config.app.platforms.includes('android')) {
+        const androidSource = textValue(values, 'google-services', true);
+        validateGoogleServices(androidSource);
+        const androidTarget = resolve(directory, 'android/app/google-services.json');
+        mkdirSync(dirname(androidTarget), { recursive: true });
+        cpSync(androidSource, androidTarget);
+        configuredPlatforms.push('Android');
+    }
+    if (config.app.platforms.includes('ios')) {
+        const iosSource = textValue(values, 'google-service-info', true);
+        validateGoogleServiceInfo(iosSource);
+        const iosTarget = resolve(directory, 'ios/App/App/GoogleService-Info.plist');
+        mkdirSync(dirname(iosTarget), { recursive: true });
+        cpSync(iosSource, iosTarget);
+        configuredPlatforms.push('iOS');
+    }
+    writeProjectConfigAndSync({
+        ...config,
+        services: {
+            ...config.services,
+            firebase: { ...config.services.firebase, enabled: true, configured: true },
+        },
+    }, directory);
+    for (const platform of config.app.platforms) {
+        runner.run(resolve(directory, 'node_modules/.bin/cap'), ['sync', platform], directory);
+    }
+    return [
+        `Firebase observability configured for ${configuredPlatforms.join(' and ')} with collection disabled until explicit consent.`,
+    ];
+}
+function configureRevenueCat(config, directory, values, runner) {
+    const iosKey = config.app.platforms.includes('ios')
+        ? textValue(values, 'ios-key', true)
+        : undefined;
+    const androidKey = config.app.platforms.includes('android')
+        ? textValue(values, 'android-key', true)
+        : undefined;
+    const entitlementId = textValue(values, 'entitlement', true);
+    const offeringId = textValue(values, 'offering', true);
+    if (iosKey && !isRevenueCatPublicKey(iosKey, 'ios')) {
+        throw new Error('RevenueCat iOS key must be an Apple public SDK key (appl_ or test_).');
+    }
+    if (androidKey && !isRevenueCatPublicKey(androidKey, 'android')) {
+        throw new Error('RevenueCat Android key must be a Google public SDK key (goog_ or test_).');
+    }
+    updateEnvFile(directory, {
+        ...(iosKey ? { MEADOW_REVENUECAT_IOS_API_KEY: iosKey } : {}),
+        ...(androidKey ? { MEADOW_REVENUECAT_ANDROID_API_KEY: androidKey } : {}),
+    });
+    writeProjectConfigAndSync({
+        ...config,
+        services: {
+            ...config.services,
+            revenuecat: {
+                ...config.services.revenuecat,
+                enabled: true,
+                configured: true,
+                mode: config.services.revenuecat.mode === 'none'
+                    ? 'subscription-and-lifetime'
+                    : config.services.revenuecat.mode,
+                entitlementId,
+                offeringId,
+            },
+        },
+    }, directory);
+    runner.run('npm', ['install'], directory);
+    for (const platform of config.app.platforms) {
+        runner.run(resolve(directory, 'node_modules/.bin/cap'), ['sync', platform], directory);
+    }
+    return [
+        `RevenueCat purchases configured for ${config.app.platforms.join(' and ')}; public SDK keys remain outside source control.`,
+    ];
+}
+function configureSupabase(config, directory, values) {
+    const url = textValue(values, 'url', true);
+    const key = textValue(values, 'publishable-key', true);
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error('Supabase URL must be an absolute URL.');
+    }
+    if (parsed.protocol !== 'https:')
+        throw new Error('Supabase URL must use https.');
+    if (/service[_-]?role|secret/i.test(key) || key.startsWith('sb_secret_')) {
+        throw new Error('Refusing to store a Supabase service-role or secret key in a client app.');
+    }
+    if (!key.startsWith('sb_publishable_') && !key.startsWith('eyJ')) {
+        throw new Error('Expected a Supabase publishable key (or legacy anon key).');
+    }
+    updateEnvFile(directory, { MEADOW_SUPABASE_URL: url, MEADOW_SUPABASE_PUBLISHABLE_KEY: key });
+    const projectRef = parsed.hostname.endsWith('.supabase.co')
+        ? parsed.hostname.slice(0, -'.supabase.co'.length)
+        : config.services.supabase.projectRef;
+    writeProjectConfigAndSync({
+        ...config,
+        services: {
+            ...config.services,
+            supabase: {
+                ...config.services.supabase,
+                enabled: true,
+                configured: true,
+                auth: 'email-otp',
+                storage: true,
+                ...(projectRef ? { projectRef } : {}),
+            },
+        },
+    }, directory);
+    return [
+        'Supabase client configuration saved to .env.meadow.local.',
+        'Before release, add explicit grants, RLS policies and database tests for every exposed table.',
+    ];
+}
+function configureAssets(_config, directory, values, runner) {
+    const source = textValue(values, 'source', true);
+    if (!existsSync(source) || !statSync(source).isFile())
+        throw new Error(`Asset source not found: ${source}`);
+    const target = resolve(directory, 'resources/icon.png');
+    mkdirSync(dirname(target), { recursive: true });
+    cpSync(source, target);
+    runner.run(localBinary(directory, 'capacitor-assets'), ['generate'], directory);
+    return ['Native icons and splash assets generated from resources/icon.png.'];
+}
+function configureSigning(directory) {
+    const path = resolve(directory, 'docs/SIGNING.md');
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `# Signing\n\nKeep signing files and passwords outside Git.\n\n- Android: provide the keystore and Gradle properties through the release environment.\n- iOS: use the Apple team, certificates, and provisioning profiles supplied by Xcode or CI secrets.\n- Never commit .jks, .keystore, .p12, .mobileprovision, or credentials.\n`);
+    return ['Signing guide created at docs/SIGNING.md.'];
+}
+function configureStore(config, directory, values) {
+    const supportEmail = textValue(values, 'support-email', false) ?? config.links.supportEmail;
+    const supportUrl = textValue(values, 'support-url', false) ?? config.links.supportUrl;
+    const privacyUrl = textValue(values, 'privacy-url', false) ?? config.links.privacyUrl;
+    const termsUrl = textValue(values, 'terms-url', false) ?? config.links.termsUrl;
+    const websiteUrl = textValue(values, 'website-url', false) ?? config.links.websiteUrl;
+    const appleAppId = textValue(values, 'apple-app-id', false) ?? config.store.appleAppId;
+    const appStoreUrl = textValue(values, 'app-store-url', false) ?? config.store.appStoreUrl;
+    const playStoreUrl = textValue(values, 'play-store-url', false) ?? config.store.playStoreUrl;
+    const next = validateProjectConfig({
+        ...config,
+        links: { ...config.links, supportEmail, supportUrl, privacyUrl, termsUrl, websiteUrl },
+        store: { ...config.store, appleAppId, appStoreUrl, playStoreUrl },
+    });
+    writeProjectConfigAndSync(next, directory);
+    return ['Store support and legal metadata updated.'];
+}
+function initializeGit(directory, config, runner) {
+    runner.run('git', ['init', '-b', 'main'], directory);
+    runner.run('git', ['add', '.'], directory);
+    runner.run('git', ['commit', '-m', `🎉 chore: initialize ${config.app.name}`], directory);
+}
+function createGithubRepository(directory, config, github, runner) {
+    if (!runner.succeeds('gh', ['auth', 'status'], directory)) {
+        throw new Error('GitHub CLI is not authenticated. Run gh auth login and try meadow configure github.');
+    }
+    const name = github.owner ? `${github.owner}/${config.app.slug}` : config.app.slug;
+    runner.run('gh', ['repo', 'create', name, `--${github.visibility}`, '--source', '.', '--remote', 'origin', '--push'], directory);
+}
+function updateEnvFile(directory, values) {
+    const path = resolve(directory, '.env.meadow.local');
+    const existing = existsSync(path) ? readFileSync(path, 'utf8').split(/\r?\n/) : [];
+    const retained = existing.filter((line) => !Object.keys(values).some((key) => line.startsWith(`${key}=`)));
+    const next = [...retained.filter(Boolean), ...Object.entries(values).map(([key, value]) => `${key}=${value}`)];
+    writeFileSync(path, `${next.join('\n')}\n`, { mode: 0o600 });
+}
+function readLocalEnvironment(directory) {
+    const path = resolve(directory, '.env.meadow.local');
+    if (!existsSync(path))
+        return {};
+    return Object.fromEntries(readFileSync(path, 'utf8')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#') && line.includes('='))
+        .map((line) => {
+        const separator = line.indexOf('=');
+        const key = line.slice(0, separator).trim();
+        const raw = line.slice(separator + 1).trim();
+        const quoted = (raw.startsWith('"') && raw.endsWith('"')) ||
+            (raw.startsWith("'") && raw.endsWith("'"));
+        return [key, quoted ? raw.slice(1, -1) : raw];
+    }));
+}
+function isRevenueCatPublicKey(value, platform) {
+    if (!value)
+        return false;
+    const normalized = value.trim();
+    return normalized.startsWith('test_') || normalized.startsWith(platform === 'ios' ? 'appl_' : 'goog_');
+}
+function writeProjectConfigAndSync(config, directory) {
+    writeProjectConfig(config, directory);
+    const result = syncProject(directory);
+    if (!result.valid) {
+        throw new Error('Configuration was saved, but generated files could not be synchronized.');
+    }
+}
+function nextFileEntries(directory) {
+    return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(directory, entry.name);
+        return entry.isDirectory() ? nextFileEntries(path) : [path];
+    });
+}
+function containsFile(directory, suffix) {
+    try {
+        return nextFileEntries(directory).some((path) => path.endsWith(suffix));
+    }
+    catch {
+        return false;
+    }
+}
+function filesContainText(root, paths, value) {
+    return paths.some((path) => {
+        try {
+            return readFileSync(resolve(root, path), 'utf8').includes(value);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function validateGoogleServices(path) {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!parsed.project_info || !Array.isArray(parsed.client)) {
+        throw new Error('google-services.json does not look like a Firebase Android config.');
+    }
+}
+function validateGoogleServiceInfo(path) {
+    const source = readFileSync(path, 'utf8');
+    if (!source.includes('<plist') || !source.includes('GOOGLE_APP_ID')) {
+        throw new Error('GoogleService-Info.plist does not look like a Firebase iOS config.');
+    }
+}
+function textValue(values, key, required) {
+    const value = values[key];
+    if (typeof value === 'string' && value.trim())
+        return value.trim();
+    if (required)
+        throw new Error(`--${key} is required.`);
+    return undefined;
+}
+function visibilityValue(value) {
+    const visibility = typeof value === 'string' ? value : 'private';
+    if (!['private', 'public', 'internal'].includes(visibility)) {
+        throw new Error('Visibility must be private, public, or internal.');
+    }
+    return visibility;
+}
+function readPackageJson(directory) {
+    const path = resolve(directory, 'package.json');
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`Could not read ${path}: ${errorMessage(error)}`);
+    }
+    if (!isRecord(parsed))
+        throw new Error(`${path} must contain a JSON object.`);
+    return parsed;
+}
+function packageDependencies(packageJson) {
+    return {
+        ...stringRecord(packageJson.dependencies, 'package.json dependencies'),
+        ...stringRecord(packageJson.devDependencies, 'package.json devDependencies'),
+    };
+}
+function stringRecord(value, label) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value) || Object.values(value).some((entry) => typeof entry !== 'string')) {
+        throw new Error(`${label} must contain dependency names and version strings.`);
+    }
+    return value;
+}
+function dependencyVersion(dependencies, name, label) {
+    const version = dependencies[name];
+    if (!version)
+        throw new Error(`meadow init requires ${label}; ${name} is missing from package.json.`);
+    return version;
+}
+function requireSupportedMajor(version, major, label) {
+    const detected = version.match(/(?:^|[^0-9])(\d+)(?:\.\d+)?/);
+    if (!detected || Number(detected[1]) !== major) {
+        throw new Error(`meadow init supports ${label} ${major}; package.json uses ${version}.`);
+    }
+}
+function findCapacitorConfig(directory) {
+    return ['capacitor.config.ts', 'capacitor.config.json'].find((name) => existsSync(resolve(directory, name)));
+}
+function readCapacitorConfig(directory) {
+    const relativePath = findCapacitorConfig(directory);
+    return relativePath ? readFileSync(resolve(directory, relativePath), 'utf8') : '';
+}
+function capacitorStringValue(source, key) {
+    const jsonMatch = source.match(new RegExp(`"${key}"\\s*:\\s*"([^"]+)"`));
+    if (jsonMatch?.[1])
+        return jsonMatch[1].trim();
+    const sourceMatch = source.match(new RegExp(key + "\\s*:\\s*['\"`]([^'\"`]+)['\"`]"));
+    return sourceMatch?.[1]?.trim() || undefined;
+}
+function slugFromPackageName(packageName, fallbackName) {
+    const candidate = packageName.replace(/^@[^/]+\//, '').trim();
+    return createProjectConfig({ name: candidate || fallbackName }).app.slug;
+}
+function titleCase(value) {
+    const title = value
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((part) => `${part[0]?.toUpperCase() ?? ''}${part.slice(1)}`)
+        .join(' ');
+    return title || undefined;
+}
+function semanticVersion(value) {
+    return typeof value === 'string' && /^\d+\.\d+\.\d+$/.test(value) ? value : undefined;
+}
+function initializedConfig(base, directory, packageVersion) {
+    const firebaseConfigured = base.app.platforms.every((platform) => existsSync(resolve(directory, platform === 'android'
+        ? 'android/app/google-services.json'
+        : 'ios/App/App/GoogleService-Info.plist')));
+    return validateProjectConfig({
+        ...base,
+        services: {
+            ...base.services,
+            firebase: { ...base.services.firebase, configured: firebaseConfigured },
+        },
+        release: { ...base.release, version: packageVersion },
+    });
+}
+function initializedPackageJson(packageJson, config, requestedPlatformSpec, replacePlatformSpec, meadowWebsite) {
+    const dependencies = stringRecord(packageJson.dependencies, 'package.json dependencies');
+    const nextDependencies = { ...dependencies };
+    if (!nextDependencies['@meadow-studio/platform'] || replacePlatformSpec) {
+        nextDependencies['@meadow-studio/platform'] = requestedPlatformSpec;
+    }
+    nextDependencies['@capacitor/app'] ??= TOOLCHAIN.capacitorApp;
+    nextDependencies['@capacitor-firebase/analytics'] ??= TOOLCHAIN.capacitorFirebase;
+    nextDependencies['@capacitor-firebase/crashlytics'] ??= TOOLCHAIN.capacitorFirebase;
+    nextDependencies.firebase ??= TOOLCHAIN.firebase;
+    if (config.services.revenuecat.enabled) {
+        nextDependencies['@revenuecat/purchases-capacitor'] ??= TOOLCHAIN.revenuecat;
+    }
+    if (config.services.supabase.enabled) {
+        nextDependencies['@supabase/supabase-js'] ??= TOOLCHAIN.supabase;
+    }
+    const scripts = stringRecord(packageJson.scripts, 'package.json scripts');
+    const nextScripts = { ...scripts };
+    nextScripts['meadow:doctor'] ??= 'meadow doctor';
+    nextScripts['release:check'] ??= 'meadow release-check all';
+    nextScripts['cap:sync'] ??= 'npx cap sync';
+    if (meadowWebsite) {
+        nextScripts['website:start'] ??= 'npm start --prefix website';
+        nextScripts['website:build'] ??= 'npm run build --prefix website';
+        nextScripts['website:check'] ??= 'npm run build --prefix website';
+    }
+    const engines = isRecord(packageJson.engines) ? { ...packageJson.engines } : {};
+    engines.node ??= '>=24.15 <25';
+    engines.npm ??= '>=11 <12';
+    return {
+        ...packageJson,
+        private: packageJson.private ?? true,
+        engines,
+        scripts: nextScripts,
+        dependencies: nextDependencies,
+    };
+}
+function scheduleWrite(writes, actions, relativePath, contents, directory, detail) {
+    const path = resolve(directory, relativePath);
+    const current = existsSync(path) ? readFileSync(path, 'utf8') : undefined;
+    if (current === contents) {
+        actions.push({ kind: 'preserve', target: relativePath, detail: 'Already matches the Meadow plan.' });
+        return;
+    }
+    writes.set(relativePath, contents);
+    actions.push({ kind: current === undefined ? 'create' : 'update', target: relativePath, detail });
+}
+function writeScheduledFiles(directory, writes) {
+    for (const [relativePath, contents] of writes) {
+        const path = resolve(directory, relativePath);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, contents);
+    }
+}
+function mergeManagedSection(source, section, startMarker, endMarker, initialHeading) {
+    const start = source.indexOf(startMarker);
+    const end = source.indexOf(endMarker);
+    if ((start >= 0) !== (end >= 0) || (start >= 0 && end < start)) {
+        throw new Error(`Cannot update managed section: expected both ${startMarker} and ${endMarker}.`);
+    }
+    const before = start >= 0 ? source.slice(0, start).trimEnd() : source.trimEnd();
+    const after = end >= 0 ? source.slice(end + endMarker.length).trimStart().trimEnd() : '';
+    const parts = [before || initialHeading, section.trim(), after].filter((part) => Boolean(part));
+    return `${parts.join('\n\n')}\n`;
+}
+function environmentExampleSection(config) {
+    const values = [];
+    if (config.services.revenuecat.enabled) {
+        values.push('MEADOW_REVENUECAT_IOS_API_KEY=', 'MEADOW_REVENUECAT_ANDROID_API_KEY=');
+    }
+    if (config.services.supabase.enabled) {
+        values.push('MEADOW_SUPABASE_URL=', 'MEADOW_SUPABASE_PUBLISHABLE_KEY=');
+    }
+    if (!values.length)
+        return undefined;
+    return `# meadow-platform:start\n# Public client configuration only. Never add secrets.\n${values.join('\n')}\n# meadow-platform:end`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function localBinary(directory, name) {
+    return resolve(directory, 'node_modules/.bin', name);
+}
+function spawnOptions(directory, stdio) {
+    return { cwd: directory, stdio, env: process.env, encoding: 'utf8' };
+}
+function pass(id, message) {
+    return { level: 'pass', id, message };
+}
+function warning(id, message) {
+    return { level: 'warning', id, message };
+}
+function failure(id, message) {
+    return { level: 'failure', id, message };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=commands.js.map