@mcamdali/sdkbump 0.0.0-stage → 0.1.3

package/dist/report/tty.js

@@ -0,0 +1,112 @@
+import { ECOSYSTEM_LABELS, GUIDES, INFO_PLIST_LABELS, LIFECYCLE_LABELS, plural, REPOSITORY_URL, wrap, } from './text.js';
+const CODES = {
+    bold: [1, 22],
+    dim: [2, 22],
+    red: [31, 39],
+    yellow: [33, 39],
+    green: [32, 39],
+    cyan: [36, 39],
+};
+const LABEL_WIDTH = 9;
+const INDENT = ' '.repeat(LABEL_WIDTH);
+const SEVERITY_STYLE = { error: 'red', warning: 'yellow', info: 'cyan' };
+const LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+function painter(color) {
+    return (style, text) => {
+        if (!color)
+            return text;
+        const [open, close] = CODES[style];
+        return `\u001b[${open}m${text}\u001b[${close}m`;
+    };
+}
+/** Each distinct fix of the report with its letter, in order of first appearance. */
+function letterFixes(findings) {
+    const result = new Map();
+    for (const item of findings) {
+        for (const fix of [item.fix, ...item.alternatives]) {
+            if (!fix || result.has(fix.id))
+                continue;
+            result.set(fix.id, { letter: LETTERS[result.size] ?? '?', fix });
+        }
+    }
+    return result;
+}
+function header(report, paint, width) {
+    const { project, rules } = report;
+    const dim = (text) => wrap(text, width).map((line) => paint('dim', line));
+    const [name = '', ...rest] = wrap(`${project.name} · ${ECOSYSTEM_LABELS[project.ecosystem]} · ${project.path}`, width);
+    const nameLength = project.name.length;
+    const lines = [
+        ...dim(`sdkbump ${report.tool.version} · rules ${rules.ruleSet}@${rules.dataVersion} · ${rules.sdk}`),
+        '',
+        `${paint('bold', name.slice(0, nameLength))}${name.slice(nameLength)}`,
+        ...rest,
+    ];
+    for (const version of project.versions) {
+        lines.push(...dim(`${version.name} ${version.version ?? '(unknown)'} (${version.source})`));
+    }
+    for (const target of project.targets) {
+        const plists = target.infoPlistSource === 'file'
+            ? target.infoPlists.join(', ')
+            : INFO_PLIST_LABELS[target.infoPlistSource];
+        lines.push(...dim(`target ${target.name}: ${LIFECYCLE_LABELS[target.lifecycle]} (${plists})`));
+    }
+    const style = report.verdict.code === 'fails-to-launch' || report.verdict.code === 'black-screen'
+        ? 'red'
+        : report.verdict.code === 'no-findings'
+            ? 'green'
+            : 'yellow';
+    lines.push('', ...wrap(report.verdict.text, width).map((line) => paint('bold', paint(style, line))), '');
+    return lines;
+}
+export function renderTty(report, options) {
+    const paint = painter(options.color);
+    const width = Math.max(60, options.width ?? 100);
+    const body = (text, style) => wrap(text, width - LABEL_WIDTH).map((line) => `${INDENT}${style ? paint(style, line) : line}`);
+    const fixes = letterFixes(report.findings);
+    const out = header(report, paint, width);
+    for (const item of report.findings) {
+        const label = (item.mitigation ? 'HANDLED' : item.severity.toUpperCase()).padEnd(LABEL_WIDTH);
+        const style = item.mitigation ? 'green' : SEVERITY_STYLE[item.severity];
+        const [titleFirst = '', ...titleRest] = wrap(`${item.rule}  ${item.title}`, width - LABEL_WIDTH);
+        out.push(`${paint('bold', paint(style, label))}${paint('bold', titleFirst)}`, ...titleRest.map((line) => `${INDENT}${paint('bold', line)}`), `${INDENT}${paint('cyan', `${item.file}${item.line ? `:${item.line}` : ''}`)}`, ...body(item.message));
+        if (item.mitigation) {
+            const { mitigation } = item;
+            const version = mitigation.version ? ` ${mitigation.version}` : '';
+            out.push(...body(`Handled at run time by ${mitigation.package}${version}. Limits: ${mitigation.limits.join(' ')}`, 'dim'));
+        }
+        const named = [item.fix, ...item.alternatives]
+            .filter((fix) => fix !== null)
+            .map((fix) => `[${fixes.get(fix.id)?.letter}] ${fix.title}`);
+        if (named.length)
+            out.push(...body(`Fix: ${named.join('; or ')}`, 'bold'));
+        out.push('');
+    }
+    if (fixes.size > 0) {
+        out.push(paint('bold', 'How to fix'), '');
+        for (const { letter, fix } of fixes.values()) {
+            out.push(`${paint('bold', `[${letter}]`.padEnd(LABEL_WIDTH))}${paint('bold', fix.title)}`);
+            fix.steps.forEach((step, index) => {
+                const marker = `${index + 1}. `;
+                const [first = '', ...rest] = wrap(step, width - LABEL_WIDTH - marker.length);
+                out.push(`${INDENT}${marker}${first}`, ...rest.map((line) => `${INDENT}${' '.repeat(marker.length)}${line}`));
+            });
+            out.push(`${INDENT}${paint('dim', fix.guide)}`, '');
+        }
+    }
+    for (const note of report.notes)
+        out.push(...wrap(`Note: ${note}`, width).map((line) => paint('dim', line)));
+    if (report.notes.length)
+        out.push('');
+    const { errors, warnings, info, mitigated } = report.summary;
+    const counts = [plural(errors, 'error'), plural(warnings, 'warning')];
+    if (info)
+        counts.push(`${info} info`);
+    if (mitigated)
+        counts.push(`${mitigated} handled by a workaround`);
+    out.push(paint('bold', counts.join(', ')), `Guide: ${GUIDES[report.project.ecosystem]}`);
+    if (report.findings.length === 0)
+        out.push(`What is checked: ${REPOSITORY_URL}#what-sdkbump-checks`);
+    return `${out.join('\n')}\n`;
+}
+//# sourceMappingURL=tty.js.map

package/dist/rules/check.d.ts

@@ -0,0 +1,11 @@
+import type { AppModel } from '../collect/app.js';
+import type { Finding } from '../model.js';
+import type { RuleData } from './data.js';
+export { adoptsScenes } from './query.js';
+export { GUIDE_BASE } from './fixes.js';
+/** A finding before paths are made relative to the checked folder. */
+export type RawFinding = Omit<Finding, 'file'> & {
+    path: string;
+};
+/** Runs every rule over the app. Findings are ordered by rule, then file and line. */
+export declare function checkApp(app: AppModel, data: RuleData): Promise<RawFinding[]>;

package/dist/rules/check.js

@@ -0,0 +1,253 @@
+import { sceneDelegateClassNames, sceneManifest } from '../collect/app.js';
+import { atLeast, majorOf } from '../core/versions.js';
+import { adoptScenesFix, bridgeAlternative, fixById, flutterMigration, hookFix, installedWorkaround, } from './fixes.js';
+import { adoptsScenes, appDelegateName, inAppDelegate, isSwiftUIApp, matches, sceneDelegateText, } from './query.js';
+import { hookPattern, REPLACEMENTS, WINDOW_CREATION, WINDOW_LOOKUPS } from './patterns.js';
+export { adoptsScenes } from './query.js';
+export { GUIDE_BASE } from './fixes.js';
+function ruleOf(data, id) {
+    const rule = data.rules.find((candidate) => candidate.id === id);
+    if (!rule)
+        throw new Error(`Rule data has no rule ${id}.`);
+    return rule;
+}
+function finding(context, rule, values) {
+    const definition = ruleOf(context.data, rule);
+    return {
+        rule,
+        severity: values.severity ?? definition.severity,
+        title: values.title ?? definition.title,
+        message: values.message,
+        path: values.path,
+        line: values.line,
+        target: values.target ?? null,
+        owner: 'app',
+        fix: values.fix,
+        alternatives: values.alternatives ?? [],
+        mitigation: installedWorkaround(context, rule),
+        sources: values.sources ?? definition.sources,
+    };
+}
+// ---------------------------------------------------------------------------------------------
+// Rules
+function scn001Expo(context) {
+    const { app, data } = context;
+    const { project } = app;
+    const expo = project.packages.get('expo');
+    const version = expo?.version ?? null;
+    const major = version ? majorOf(version) : null;
+    const config = project.expoConfig;
+    const file = config?.file ?? 'package.json';
+    const path = `${project.root}/${file}`;
+    const byDefault = majorOf(data.milestones.expoScenesByDefault) ?? 58;
+    const supported = majorOf(data.milestones.expoSceneSupport) ?? 57;
+    if (major !== null && major >= byDefault)
+        return [];
+    const prefix = 'There is no ios/ folder, so this comes from the Expo configuration:';
+    if (major === supported) {
+        const missing = [];
+        if (version && !atLeast(version, data.milestones.expoSceneSupport)) {
+            missing.push(`expo is ${version}; scene support needs ${data.milestones.expoSceneSupport} or later`);
+        }
+        const buildProperties = project.packages.get('expo-build-properties');
+        if (!buildProperties)
+            missing.push('expo-build-properties is not a dependency');
+        else if (buildProperties.version &&
+            !atLeast(buildProperties.version, data.milestones.expoBuildProperties)) {
+            missing.push(`expo-build-properties is ${buildProperties.version}; ${data.milestones.expoBuildProperties} or later is needed`);
+        }
+        if (config?.enableSceneSupport === null) {
+            return [
+                finding(context, 'SCN001', {
+                    severity: 'warning',
+                    message: `${prefix} ${file} is code, which sdkbump does not run. Built with Expo SDK ${supported} and the iOS 27 SDK, the app launches only if that config sets expo-build-properties ios.enableSceneSupport to true.${missing.length ? ` Also: ${missing.join('; ')}.` : ''}`,
+                    path,
+                    line: null,
+                    fix: fixById(data, 'expo-57-scene-support'),
+                    alternatives: bridgeAlternative(context),
+                }),
+            ];
+        }
+        if (config?.enableSceneSupport !== true) {
+            missing.unshift(`${file} does not set expo-build-properties ios.enableSceneSupport to true`);
+        }
+        if (missing.length === 0)
+            return [];
+        return [
+            finding(context, 'SCN001', {
+                message: `${prefix} Expo SDK ${supported} uses the scene life cycle only when you opt in, and ${missing.join('; ')}. Built with the iOS 27 SDK, the app stops at launch.`,
+                path,
+                line: null,
+                fix: fixById(data, 'expo-57-scene-support'),
+                alternatives: bridgeAlternative(context),
+            }),
+        ];
+    }
+    return [
+        finding(context, 'SCN001', {
+            message: `${prefix} expo ${version ?? expo?.declared ?? '(unknown version)'} has no scene support. Built with the iOS 27 SDK, the app stops at launch.`,
+            path: `${project.root}/package.json`,
+            line: null,
+            fix: fixById(data, 'expo-upgrade'),
+            alternatives: bridgeAlternative(context),
+        }),
+    ];
+}
+/**
+ * The target's Info.plist could not be read, so whether it declares a scene is not known. An
+ * error here would be a guess: the file may well have a scene manifest.
+ */
+function scn001NotRead(context, target) {
+    const { app } = context;
+    return finding(context, 'SCN001', {
+        severity: 'info',
+        title: 'Scene configuration not checked',
+        message: `sdkbump could not read the Info.plist of ${target.name} (see the notes), so it cannot tell whether the app declares a scene. ${appDelegateName(app)} does not implement application(_:configurationForConnecting:options:), so built with the iOS 27 SDK the app launches only if that Info.plist has a UIApplicationSceneManifest with a scene configuration.`,
+        path: `${target.xcodeProject}/project.pbxproj`,
+        line: null,
+        target: target.name,
+        fix: null,
+    });
+}
+function scn001(context) {
+    const { app } = context;
+    if (app.project.ecosystem === 'expo' && !app.project.iosDir)
+        return scn001Expo(context);
+    const results = [];
+    for (const target of app.targets) {
+        if (adoptsScenes(app, target))
+            continue;
+        if (target.infoPlistSource === 'not-read') {
+            results.push(scn001NotRead(context, target));
+            continue;
+        }
+        const plist = target.infoPlists[0];
+        const manifest = plist ? sceneManifest(plist) : { present: false, configured: false };
+        const where = plist ? 'Info.plist' : 'The Info.plist Xcode generates';
+        const declared = manifest.present
+            ? `${where} has UIApplicationSceneManifest but no scene configuration`
+            : `${where} has no UIApplicationSceneManifest`;
+        let message = `${declared}, and ${appDelegateName(app)} does not implement application(_:configurationForConnecting:options:). Built with the iOS 27 SDK, the app stops at launch: "UIScene life cycle is required for apps built with this SDK".`;
+        if (app.project.ecosystem === 'flutter' && context.flutter && !context.flutter.eligible) {
+            message += ` Flutter will not migrate it automatically: ${context.flutter.reasons.join(' ')}`;
+        }
+        if (app.project.ecosystem === 'expo' && app.project.expoConfig?.enableSceneSupport) {
+            message += ` ${app.project.expoConfig.file} turns scene support on, but ios/ was generated before.`;
+        }
+        const { fix, alternatives } = adoptScenesFix(context);
+        results.push(finding(context, 'SCN001', {
+            message,
+            path: plist?.path ?? `${target.xcodeProject}/project.pbxproj`,
+            line: plist?.keyLines.get('UIApplicationSceneManifest') ?? null,
+            target: target.name,
+            fix,
+            alternatives,
+        }));
+    }
+    return results;
+}
+function scn002(context) {
+    const { app, data } = context;
+    if (isSwiftUIApp(app))
+        return [];
+    const results = [];
+    const nativeLike = app.project.ecosystem === 'native' || app.project.ecosystem === 'flutter';
+    for (const match of matches(app.sources.files, (file) => WINDOW_CREATION[file.language])) {
+        if (!inAppDelegate(app, match))
+            continue;
+        const { fix, alternatives } = nativeLike
+            ? { fix: fixById(data, 'native-window-in-scene'), alternatives: [] }
+            : adoptScenesFix(context);
+        results.push(finding(context, 'SCN002', {
+            message: `${appDelegateName(app)} creates the window with ${match.file.language === 'swift' ? 'UIWindow(frame:)' : '[[UIWindow alloc] initWithFrame:]'}. With a scene, UIKit does not show a window that belongs to no scene, and the app opens to a black screen.`,
+            path: match.file.path,
+            line: match.file.lineAt(match.offset),
+            fix,
+            alternatives,
+        }));
+    }
+    return results;
+}
+/**
+ * Whether the app's scene delegate passes scene events on to the app delegate: a scene delegate
+ * class in the sources that derives from a forwarder, or a forwarder named directly in Info.plist
+ * (Expo SDK 57's opt-in writes EXExpoAppSceneDelegate there and adds no class of its own).
+ */
+function usesForwardingSceneDelegate(app, forwarders) {
+    const derived = app.sources.regions.some((region) => app.sources.sceneDelegates.has(region.name) &&
+        region.inherits.some((parent) => forwarders.includes(parent)));
+    if (derived)
+        return true;
+    return app.targets.some((target) => target.infoPlists.some((plist) => sceneDelegateClassNames(plist).some((name) => forwarders.includes(name))));
+}
+function scn003(context) {
+    const { app, data } = context;
+    const forwarding = usesForwardingSceneDelegate(app, data.sceneForwarders);
+    if (forwarding)
+        return [];
+    const swiftUI = isSwiftUIApp(app);
+    const sceneCode = sceneDelegateText(app);
+    const allCode = app.sources.files.map((file) => file.code).join('\n');
+    const results = [];
+    for (const hook of data.hooks) {
+        const replacement = REPLACEMENTS[hook.id];
+        if (replacement?.uikit.test(sceneCode))
+            continue;
+        if (swiftUI && replacement?.swiftUI?.test(allCode))
+            continue;
+        for (const match of matches(app.sources.files, (file) => hookPattern(hook, file.language))) {
+            if (!inAppDelegate(app, match))
+                continue;
+            const name = match.file.language === 'swift' ? hook.swift : hook.objc;
+            const what = hook.kind === 'method'
+                ? 'UIKit does not call this method'
+                : 'UIKit does not put this key in the launch options';
+            const message = swiftUI
+                ? `A SwiftUI App runs on scenes, so ${what}${hook.kind === 'method' ? ' on the adaptor delegate' : ''}. Use ${hook.swiftUI ?? hook.replacement} instead.`
+                : `${what} once the app uses scenes. Use ${hook.replacement}.`;
+            results.push(finding(context, 'SCN003', {
+                title: hook.kind === 'method'
+                    ? `${name} is not called with scenes`
+                    : `${name} is empty with scenes`,
+                message,
+                path: match.file.path,
+                line: match.file.lineAt(match.offset),
+                fix: hookFix(context, hook, swiftUI),
+                sources: hook.sources,
+            }));
+        }
+    }
+    return results;
+}
+function scn004(context) {
+    const { app, data } = context;
+    const results = [];
+    for (const lookup of data.windowLookups) {
+        const pattern = WINDOW_LOOKUPS[lookup.id];
+        if (!pattern)
+            continue;
+        for (const match of matches(app.sources.files, (file) => pattern[file.language])) {
+            if (pattern.inAppDelegateOnly && !inAppDelegate(app, match))
+                continue;
+            const flutterChannel = app.project.ecosystem === 'flutter' && lookup.id === 'app-delegate-window';
+            results.push(finding(context, 'SCN004', {
+                title: lookup.title,
+                message: lookup.message,
+                path: match.file.path,
+                line: match.file.lineAt(match.offset),
+                fix: fixById(data, flutterChannel ? 'flutter-engine-bridge' : 'window-from-scene'),
+                sources: lookup.sources,
+            }));
+        }
+    }
+    return results;
+}
+/** Runs every rule over the app. Findings are ordered by rule, then file and line. */
+export async function checkApp(app, data) {
+    const context = { app, data };
+    if (app.project.ecosystem === 'flutter')
+        context.flutter = await flutterMigration(app, data);
+    const all = [...scn001(context), ...scn002(context), ...scn003(context), ...scn004(context)];
+    return all.sort((a, b) => a.rule.localeCompare(b.rule) || a.path.localeCompare(b.path) || (a.line ?? 0) - (b.line ?? 0));
+}
+//# sourceMappingURL=check.js.map

package/dist/rules/data.d.ts

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+declare const Source: z.ZodObject<{
+    title: z.ZodString;
+    url: z.ZodURL;
+}, z.core.$strict>;
+declare const Ecosystem: z.ZodEnum<{
+    expo: "expo";
+    flutter: "flutter";
+    native: "native";
+    "react-native": "react-native";
+}>;
+/** The rules of this rule set. */
+export declare const RULE_IDS: readonly ['SCN001', 'SCN002', 'SCN003', 'SCN004'];
+export type RuleId = (typeof RULE_IDS)[number];
+/** Severities, highest first. */
+export declare const SEVERITIES: readonly ['error', 'warning', 'info'];
+export type Severity = (typeof SEVERITIES)[number];
+declare const Rule: z.ZodObject<{
+    id: z.ZodEnum<{
+        SCN001: "SCN001";
+        SCN002: "SCN002";
+        SCN003: "SCN003";
+        SCN004: "SCN004";
+    }>;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    title: z.ZodString;
+    summary: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodURL;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const Hook: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        "launch-option": "launch-option";
+        method: "method";
+    }>;
+    swift: z.ZodString;
+    objc: z.ZodString;
+    replacement: z.ZodString;
+    swiftUI: z.ZodNullable<z.ZodString>;
+    sources: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodURL;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const WindowLookup: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    api: z.ZodString;
+    message: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodURL;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const Fix: z.ZodObject<{
+    id: z.ZodString;
+    ecosystems: z.ZodArray<z.ZodEnum<{
+        expo: "expo";
+        flutter: "flutter";
+        native: "native";
+        "react-native": "react-native";
+    }>>;
+    title: z.ZodString;
+    steps: z.ZodArray<z.ZodString>;
+    guide: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodURL;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const Workaround: z.ZodObject<{
+    package: z.ZodString;
+    ecosystems: z.ZodArray<z.ZodEnum<{
+        expo: "expo";
+        flutter: "flutter";
+        native: "native";
+        "react-native": "react-native";
+    }>>;
+    mitigates: z.ZodArray<z.ZodEnum<{
+        SCN001: "SCN001";
+        SCN002: "SCN002";
+        SCN003: "SCN003";
+        SCN004: "SCN004";
+    }>>;
+    summary: z.ZodString;
+    limits: z.ZodArray<z.ZodString>;
+    sources: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodURL;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const RuleDataSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    ruleSet: z.ZodString;
+    dataVersion: z.ZodString;
+    sdk: z.ZodString;
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            SCN001: "SCN001";
+            SCN002: "SCN002";
+            SCN003: "SCN003";
+            SCN004: "SCN004";
+        }>;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        title: z.ZodString;
+        summary: z.ZodString;
+        sources: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    hooks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            "launch-option": "launch-option";
+            method: "method";
+        }>;
+        swift: z.ZodString;
+        objc: z.ZodString;
+        replacement: z.ZodString;
+        swiftUI: z.ZodNullable<z.ZodString>;
+        sources: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    windowLookups: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        api: z.ZodString;
+        message: z.ZodString;
+        sources: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    fixes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        ecosystems: z.ZodArray<z.ZodEnum<{
+            expo: "expo";
+            flutter: "flutter";
+            native: "native";
+            "react-native": "react-native";
+        }>>;
+        title: z.ZodString;
+        steps: z.ZodArray<z.ZodString>;
+        guide: z.ZodString;
+        sources: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    workarounds: z.ZodArray<z.ZodObject<{
+        package: z.ZodString;
+        ecosystems: z.ZodArray<z.ZodEnum<{
+            expo: "expo";
+            flutter: "flutter";
+            native: "native";
+            "react-native": "react-native";
+        }>>;
+        mitigates: z.ZodArray<z.ZodEnum<{
+            SCN001: "SCN001";
+            SCN002: "SCN002";
+            SCN003: "SCN003";
+            SCN004: "SCN004";
+        }>>;
+        summary: z.ZodString;
+        limits: z.ZodArray<z.ZodString>;
+        sources: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    milestones: z.ZodObject<{
+        reactNativeScenes: z.ZodString;
+        expoSceneSupport: z.ZodString;
+        expoBuildProperties: z.ZodString;
+        expoScenesByDefault: z.ZodString;
+        flutterAutoMigration: z.ZodString;
+    }, z.core.$strict>;
+    sceneForwarders: z.ZodArray<z.ZodString>;
+    flutterTemplates: z.ZodObject<{
+        source: z.ZodURL;
+        swift: z.ZodArray<z.ZodString>;
+        objcHeader: z.ZodString;
+        objcImplementation: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RuleData = z.infer<typeof RuleDataSchema>;
+export type Ecosystem = z.infer<typeof Ecosystem>;
+export type RuleSource = z.infer<typeof Source>;
+export type RuleDefinition = z.infer<typeof Rule>;
+export type HookDefinition = z.infer<typeof Hook>;
+export type WindowLookupDefinition = z.infer<typeof WindowLookup>;
+export type FixDefinition = z.infer<typeof Fix>;
+export type WorkaroundDefinition = z.infer<typeof Workaround>;
+export declare class RuleDataError extends Error {
+    name: string;
+}
+/** Validates rule data; throws RuleDataError listing every problem. */
+export declare function parseRuleData(value: unknown): RuleData;
+/** The bundled rules/ios27.json (one level above src/ and dist/). */
+export declare function loadRuleData(): RuleData;
+/** JSON schema of the rule data, written to rules/schema.json. */
+export declare function ruleDataJsonSchema(): unknown;
+export {};