@mcamdali/sdkbump 0.0.0-stage → 0.1.3

package/dist/rules/data.js

@@ -0,0 +1,141 @@
+// The rule data (rules/ios27.json): what each rule says, the fixes and workarounds sdkbump can
+// suggest, and the source every statement rests on. Validated with zod when loaded; the JSON
+// schema in rules/schema.json is generated from the same definition.
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+const Source = z
+    .object({
+    title: z.string().min(1),
+    url: z.url({ protocol: /^https$/ }),
+})
+    .strict();
+const Ecosystem = z.enum(['native', 'flutter', 'react-native', 'expo']);
+/** The rules of this rule set. */
+export const RULE_IDS = ['SCN001', 'SCN002', 'SCN003', 'SCN004'];
+/** Severities, highest first. */
+export const SEVERITIES = ['error', 'warning', 'info'];
+const RuleIdSchema = z.enum(RULE_IDS);
+const SeveritySchema = z.enum(SEVERITIES);
+/** Every rule, hook, lookup, fix and workaround cites at least one source. */
+const Sources = z.array(Source).min(1);
+const Rule = z
+    .object({
+    id: RuleIdSchema,
+    severity: SeveritySchema,
+    title: z.string().min(1),
+    summary: z.string().min(1),
+    sources: Sources,
+})
+    .strict();
+const Hook = z
+    .object({
+    id: z.string().regex(/^[a-z-]+$/),
+    kind: z.enum(['method', 'launch-option']),
+    swift: z.string().min(1),
+    objc: z.string().min(1),
+    replacement: z.string().min(1),
+    swiftUI: z.string().nullable(),
+    sources: Sources,
+})
+    .strict();
+const WindowLookup = z
+    .object({
+    id: z.string().regex(/^[a-z-]+$/),
+    title: z.string().min(1),
+    api: z.string().min(1),
+    message: z.string().min(1),
+    sources: Sources,
+})
+    .strict();
+const Fix = z
+    .object({
+    id: z.string().regex(/^[a-z0-9-]+$/),
+    ecosystems: z.array(Ecosystem).min(1),
+    title: z.string().min(1),
+    steps: z.array(z.string().min(1)).min(1),
+    guide: z.string().regex(/^docs\/guides\/[a-z0-9-]+\.md$/),
+    sources: Sources,
+})
+    .strict();
+const Workaround = z
+    .object({
+    package: z.string().min(1),
+    ecosystems: z.array(Ecosystem).min(1),
+    mitigates: z.array(RuleIdSchema).min(1),
+    summary: z.string().min(1),
+    limits: z.array(z.string().min(1)),
+    sources: Sources,
+})
+    .strict();
+const Version = z.string().regex(/^\d+\.\d+\.\d+$/);
+const Sha256 = z.string().regex(/^[0-9a-f]{64}$/);
+export const RuleDataSchema = z
+    .object({
+    $schema: z.string().optional(),
+    ruleSet: z.string().regex(/^[a-z0-9]+$/),
+    /** Date of the last change, YYYY.MM.DD. */
+    dataVersion: z.string().regex(/^\d{4}\.\d{2}\.\d{2}$/),
+    sdk: z.string().min(1),
+    rules: z.array(Rule).min(1),
+    hooks: z.array(Hook).min(1),
+    windowLookups: z.array(WindowLookup).min(1),
+    fixes: z.array(Fix).min(1),
+    workarounds: z.array(Workaround),
+    milestones: z
+        .object({
+        reactNativeScenes: Version,
+        expoSceneSupport: Version,
+        expoBuildProperties: Version,
+        expoScenesByDefault: Version,
+        flutterAutoMigration: Version,
+    })
+        .strict(),
+    /** Scene delegate base classes that pass scene events on to the app delegate. */
+    sceneForwarders: z.array(z.string().min(1)),
+    /** SHA-256 of the trimmed AppDelegate files Flutter's migrator recognises as unmodified. */
+    flutterTemplates: z
+        .object({
+        source: z.url({ protocol: /^https$/ }),
+        swift: z.array(Sha256).min(1),
+        objcHeader: Sha256,
+        objcImplementation: Sha256,
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((data, context) => {
+    const unique = (label, ids) => {
+        const seen = new Set();
+        for (const id of ids) {
+            if (seen.has(id))
+                context.addIssue({ code: 'custom', message: `Duplicate ${label} id ${id}` });
+            seen.add(id);
+        }
+    };
+    unique('rule', data.rules.map((rule) => rule.id));
+    unique('hook', data.hooks.map((hook) => hook.id));
+    unique('window lookup', data.windowLookups.map((lookup) => lookup.id));
+    unique('fix', data.fixes.map((fix) => fix.id));
+});
+export class RuleDataError extends Error {
+    name = 'RuleDataError';
+}
+/** Validates rule data; throws RuleDataError listing every problem. */
+export function parseRuleData(value) {
+    const result = RuleDataSchema.safeParse(value);
+    if (result.success)
+        return result.data;
+    const problems = result.error.issues.map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`);
+    throw new RuleDataError(`Invalid rule data:\n${problems.join('\n')}`);
+}
+let cached;
+/** The bundled rules/ios27.json (one level above src/ and dist/). */
+export function loadRuleData() {
+    cached ??= parseRuleData(JSON.parse(readFileSync(new URL('../../rules/ios27.json', import.meta.url), 'utf8')));
+    return cached;
+}
+/** JSON schema of the rule data, written to rules/schema.json. */
+export function ruleDataJsonSchema() {
+    return z.toJSONSchema(RuleDataSchema, { io: 'input', unrepresentable: 'any' });
+}
+//# sourceMappingURL=data.js.map

package/dist/rules/fixes.d.ts

@@ -0,0 +1,28 @@
+import { type AppModel } from '../collect/app.js';
+import type { FixAdvice, Mitigation } from '../model.js';
+import type { HookDefinition, RuleData, RuleId } from './data.js';
+/** Where guides are linked from reports. */
+export declare const GUIDE_BASE = "https://github.com/muhittincamdali/sdkbump/blob/main/";
+export interface Context {
+    app: AppModel;
+    data: RuleData;
+    /** Flutter auto-migration eligibility, computed before the rules run. */
+    flutter?: FlutterMigration;
+}
+export interface FlutterMigration {
+    eligible: boolean;
+    /** Why the Flutter tool will not migrate the app by itself. */
+    reasons: string[];
+}
+export declare function fixById(data: RuleData, id: string): FixAdvice;
+export declare function installedWorkaround(context: Context, rule: RuleId): Mitigation | null;
+/** Mirrors the conditions of Flutter's UISceneMigration (flutter_tools, 3.41 and later). */
+export declare function flutterMigration(app: AppModel, data: RuleData): Promise<FlutterMigration>;
+export declare function bridgeAlternative(context: Context): FixAdvice[];
+/** The fix for an app without scenes, by ecosystem and version. */
+export declare function adoptScenesFix(context: Context): {
+    fix: FixAdvice;
+    alternatives: FixAdvice[];
+};
+export declare function expoFix(context: Context): FixAdvice;
+export declare function hookFix(context: Context, hook: HookDefinition, swiftUI: boolean): FixAdvice;

package/dist/rules/fixes.js

@@ -0,0 +1,161 @@
+// Which fix applies to a finding: by ecosystem, version and (for Flutter) whether the Flutter tool
+// can migrate the app by itself; and which installed workaround handles it at run time.
+import { createHash } from 'node:crypto';
+import { flutterAppDelegatePaths } from '../collect/app.js';
+import { readProjectText } from '../core/files.js';
+import { atLeast, majorOf } from '../core/versions.js';
+/** Where guides are linked from reports. */
+export const GUIDE_BASE = 'https://github.com/muhittincamdali/sdkbump/blob/main/';
+export function fixById(data, id) {
+    const fix = data.fixes.find((candidate) => candidate.id === id);
+    if (!fix)
+        throw new Error(`Rule data has no fix ${id}.`);
+    return toAdvice(fix);
+}
+const toAdvice = (fix) => ({
+    id: fix.id,
+    title: fix.title,
+    steps: fix.steps,
+    guide: GUIDE_BASE + fix.guide,
+    sources: fix.sources,
+});
+function workaroundAdvice(workaround) {
+    return {
+        id: `workaround-${workaround.package}`,
+        title: `Temporary: install ${workaround.package}`,
+        steps: [workaround.summary, ...workaround.limits.map((limit) => `Limit: ${limit}`)],
+        guide: `${GUIDE_BASE}docs/guides/react-native-expo.md`,
+        sources: workaround.sources,
+    };
+}
+export function installedWorkaround(context, rule) {
+    const { project } = context.app;
+    for (const workaround of context.data.workarounds) {
+        const installed = project.packages.get(workaround.package);
+        if (!installed || !workaround.mitigates.includes(rule))
+            continue;
+        if (!workaround.ecosystems.includes(project.ecosystem))
+            continue;
+        return {
+            package: workaround.package,
+            version: installed.version,
+            summary: workaround.summary,
+            limits: workaround.limits,
+            sources: workaround.sources,
+        };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------------------------
+// Fix selection
+const sha256 = (text) => createHash('sha256').update(text.trim()).digest('hex');
+/** Mirrors the conditions of Flutter's UISceneMigration (flutter_tools, 3.41 and later). */
+export async function flutterMigration(app, data) {
+    const reasons = [];
+    const { project } = app;
+    if (project.flutter?.migrationDisabled) {
+        reasons.push('pubspec.yaml sets enable-uiscene-migration: false.');
+    }
+    const runner = app.targets.find((target) => target.name === 'Runner') ?? app.targets[0];
+    const storyboard = runner?.infoPlists[0]?.dict.UIMainStoryboardFile;
+    if (storyboard !== 'Main') {
+        reasons.push('Info.plist does not set UIMainStoryboardFile to Main.');
+    }
+    const paths = flutterAppDelegatePaths(project.iosDir ?? project.root);
+    const read = (path) => readProjectText(path, project.root);
+    const swift = await read(paths.swift);
+    if (swift !== null) {
+        if (!data.flutterTemplates.swift.includes(sha256(swift))) {
+            reasons.push('ios/Runner/AppDelegate.swift differs from the templates Flutter migrates.');
+        }
+    }
+    else {
+        const [header, implementation] = await Promise.all([
+            read(paths.objcHeader),
+            read(paths.objcImplementation),
+        ]);
+        if (header === null ||
+            implementation === null ||
+            sha256(header) !== data.flutterTemplates.objcHeader ||
+            sha256(implementation) !== data.flutterTemplates.objcImplementation) {
+            reasons.push('ios/Runner/AppDelegate.h and .m differ from the template Flutter migrates.');
+        }
+    }
+    return { eligible: reasons.length === 0, reasons };
+}
+export function bridgeAlternative(context) {
+    const { project } = context.app;
+    if (project.ecosystem !== 'react-native' && project.ecosystem !== 'expo')
+        return [];
+    if (context.data.workarounds.some((workaround) => project.packages.has(workaround.package))) {
+        return [];
+    }
+    const bridge = context.data.workarounds.find((workaround) => workaround.package === 'react-native-uiscene-bridge');
+    return bridge ? [workaroundAdvice(bridge)] : [];
+}
+/** The fix for an app without scenes, by ecosystem and version. */
+export function adoptScenesFix(context) {
+    const { data, app } = context;
+    const { project } = app;
+    switch (project.ecosystem) {
+        case 'native':
+            return { fix: fixById(data, 'native-adopt-scenes'), alternatives: [] };
+        case 'flutter':
+            return context.flutter?.eligible
+                ? {
+                    fix: fixById(data, 'flutter-auto-migrate'),
+                    alternatives: [fixById(data, 'flutter-manual-migration')],
+                }
+                : { fix: fixById(data, 'flutter-manual-migration'), alternatives: [] };
+        case 'react-native': {
+            const version = project.packages.get('react-native')?.version;
+            const upgraded = version && atLeast(version, data.milestones.reactNativeScenes);
+            return upgraded
+                ? {
+                    fix: fixById(data, 'rn-manual-scene-delegate'),
+                    alternatives: bridgeAlternative(context),
+                }
+                : {
+                    fix: fixById(data, 'rn-upgrade-088'),
+                    alternatives: [
+                        fixById(data, 'rn-manual-scene-delegate'),
+                        ...bridgeAlternative(context),
+                    ],
+                };
+        }
+        case 'expo':
+            return { fix: expoFix(context), alternatives: bridgeAlternative(context) };
+    }
+}
+export function expoFix(context) {
+    const { data, app } = context;
+    const version = app.project.packages.get('expo')?.version ?? null;
+    const major = version ? majorOf(version) : null;
+    if (major !== null && major >= (majorOf(data.milestones.expoScenesByDefault) ?? 58)) {
+        return fixById(data, 'expo-prebuild');
+    }
+    if (major === (majorOf(data.milestones.expoSceneSupport) ?? 57)) {
+        return app.project.expoConfig?.enableSceneSupport === true && app.project.iosDir
+            ? fixById(data, 'expo-prebuild')
+            : fixById(data, 'expo-57-scene-support');
+    }
+    return fixById(data, 'expo-upgrade');
+}
+export function hookFix(context, hook, swiftUI) {
+    const { data, app } = context;
+    switch (app.project.ecosystem) {
+        case 'flutter':
+            return fixById(data, 'flutter-scene-delegate-hooks');
+        case 'react-native':
+            return hook.id === 'open-url' || hook.id === 'continue-user-activity'
+                ? fixById(data, 'rn-linking-scene')
+                : fixById(data, 'native-move-hook');
+        case 'expo':
+            return expoFix(context);
+        case 'native':
+            return swiftUI && hook.swiftUI
+                ? fixById(data, 'swiftui-modifier')
+                : fixById(data, 'native-move-hook');
+    }
+}
+//# sourceMappingURL=fixes.js.map

package/dist/rules/patterns.d.ts

@@ -0,0 +1,29 @@
+import type { Language } from '../collect/sources.js';
+import type { HookDefinition } from './data.js';
+/**
+ * The declaration of an app delegate method, built from its names in the rule data:
+ * "application(_:open:options:)" matches `func application(_ app: UIApplication, open url: …`,
+ * "application:openURL:options:" matches `- (BOOL)application:(UIApplication *)app openURL:…`.
+ */
+export declare function methodPattern(hook: HookDefinition, language: Language): RegExp;
+/** A read of a launch option key: `launchOptions?[.url]`, `UIApplicationLaunchOptionsURLKey`. */
+export declare function launchOptionPattern(hook: HookDefinition, language: Language): RegExp;
+export declare function hookPattern(hook: HookDefinition, language: Language): RegExp;
+/**
+ * What implementing each hook's replacement looks like in a scene delegate (UIKit) or anywhere in
+ * a SwiftUI app. A hook whose replacement is already there is not reported.
+ */
+export declare const REPLACEMENTS: Record<string, {
+    uikit: RegExp;
+    swiftUI: RegExp | null;
+}>;
+/** Window lookups through the application, by window lookup id. */
+export declare const WINDOW_LOOKUPS: Record<string, {
+    swift: RegExp;
+    objc: RegExp;
+    inAppDelegateOnly: boolean;
+}>;
+/** The app delegate creating a window of its own. */
+export declare const WINDOW_CREATION: Record<Language, RegExp>;
+/** An app delegate that supplies scene configurations in code. */
+export declare const CONFIGURATION_FOR_CONNECTING: Record<Language, RegExp>;

package/dist/rules/patterns.js

@@ -0,0 +1,109 @@
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * The declaration of an app delegate method, built from its names in the rule data:
+ * "application(_:open:options:)" matches `func application(_ app: UIApplication, open url: …`,
+ * "application:openURL:options:" matches `- (BOOL)application:(UIApplication *)app openURL:…`.
+ */
+export function methodPattern(hook, language) {
+    if (language === 'swift') {
+        const match = /^(\w+)\(([^)]*)\)$/.exec(hook.swift);
+        if (!match)
+            throw new Error(`Hook ${hook.id}: "${hook.swift}" is not a Swift method name.`);
+        const [, name = '', labels = ''] = match;
+        const second = labels.split(':')[1];
+        const tail = second
+            ? `\\s*\\(\\s*_\\s+\\w+\\s*:[^,)]*,\\s*${escapeRegExp(second)}\\b`
+            : '\\s*\\(';
+        return new RegExp(`\\bfunc\\s+${escapeRegExp(name)}${tail}`, 'g');
+    }
+    const parts = hook.objc.split(':').filter(Boolean);
+    const [first = '', second] = parts;
+    const tail = second ? `\\s*:\\s*\\([^)]*\\)\\s*\\w+\\s+${escapeRegExp(second)}\\s*:` : '\\s*:';
+    return new RegExp(`^\\s*-\\s*\\([^)]*\\)\\s*${escapeRegExp(first)}${tail}`, 'gm');
+}
+/** A read of a launch option key: `launchOptions?[.url]`, `UIApplicationLaunchOptionsURLKey`. */
+export function launchOptionPattern(hook, language) {
+    if (language === 'objc')
+        return new RegExp(`\\b${escapeRegExp(hook.objc)}\\b`, 'g');
+    const key = /\[\.(\w+)\]$/.exec(hook.swift)?.[1];
+    if (!key)
+        throw new Error(`Hook ${hook.id}: "${hook.swift}" is not a launch option key.`);
+    return new RegExp(`\\[\\s*(?:UIApplication\\s*\\.\\s*LaunchOptionsKey\\s*)?\\.\\s*${key}\\s*\\]|LaunchOptionsKey\\s*\\.\\s*${key}\\b`, 'g');
+}
+export function hookPattern(hook, language) {
+    return hook.kind === 'method'
+        ? methodPattern(hook, language)
+        : launchOptionPattern(hook, language);
+}
+/**
+ * What implementing each hook's replacement looks like in a scene delegate (UIKit) or anywhere in
+ * a SwiftUI app. A hook whose replacement is already there is not reported.
+ */
+export const REPLACEMENTS = {
+    'open-url': { uikit: /\bopenURLContexts\b/, swiftUI: /\.onOpenURL\b/ },
+    'continue-user-activity': {
+        uikit: /\bcontinue\s+\w+\s*:\s*NSUserActivity\b|\bscene\s*:\s*\([^)]*\)\s*\w+\s+continueUserActivity\s*:/,
+        swiftUI: /\.onContinueUserActivity\b/,
+    },
+    'will-continue-user-activity': { uikit: /\bwillContinueUserActivityWithType\b/, swiftUI: null },
+    'fail-to-continue-user-activity': {
+        uikit: /\bdidFailToContinueUserActivityWithType\b/,
+        swiftUI: null,
+    },
+    'quick-action': {
+        uikit: /\bwindowScene\b[^{;]*\bperformAction(?:For|ForShortcutItem)\b/,
+        swiftUI: null,
+    },
+    'did-become-active': { uikit: /\bsceneDidBecomeActive\b/, swiftUI: /\bscenePhase\b/ },
+    'will-resign-active': { uikit: /\bsceneWillResignActive\b/, swiftUI: /\bscenePhase\b/ },
+    'did-enter-background': { uikit: /\bsceneDidEnterBackground\b/, swiftUI: /\bscenePhase\b/ },
+    'will-enter-foreground': { uikit: /\bsceneWillEnterForeground\b/, swiftUI: /\bscenePhase\b/ },
+    'launch-url': {
+        uikit: /\bconnectionOptions\s*\.\s*(?:urlContexts|URLContexts)\b/,
+        swiftUI: /\.onOpenURL\b/,
+    },
+    'launch-user-activity': {
+        uikit: /\bconnectionOptions\s*\.\s*userActivities\b/,
+        swiftUI: /\.onContinueUserActivity\b/,
+    },
+    'launch-shortcut-item': { uikit: /\bconnectionOptions\s*\.\s*shortcutItem\b/, swiftUI: null },
+    'launch-remote-notification': {
+        uikit: /\buserNotificationCenter\s*\(\s*_\s+\w+\s*:\s*UNUserNotificationCenter\s*,\s*didReceive\b|userNotificationCenter\s*:\s*\([^)]*\)\s*\w+\s+didReceiveNotificationResponse\s*:/,
+        swiftUI: null,
+    },
+};
+/** Window lookups through the application, by window lookup id. */
+export const WINDOW_LOOKUPS = {
+    'key-window': {
+        swift: /\bUIApplication\s*\.\s*shared\s*\.\s*keyWindow\b/g,
+        objc: /\[\s*UIApplication\s+sharedApplication\s*\]\s*(?:\.\s*keyWindow\b|keyWindow\s*\])|\[\s*\[\s*UIApplication\s+sharedApplication\s*\]\s+keyWindow\s*\]/g,
+        inAppDelegateOnly: false,
+    },
+    windows: {
+        swift: /\bUIApplication\s*\.\s*shared\s*\.\s*windows\b/g,
+        objc: /\[\s*UIApplication\s+sharedApplication\s*\]\s*\.\s*windows\b|\[\s*\[\s*UIApplication\s+sharedApplication\s*\]\s+windows\s*\]/g,
+        inAppDelegateOnly: false,
+    },
+    'delegate-window': {
+        swift: /\bUIApplication\s*\.\s*shared\s*\.\s*delegate\s*[?!]?\s*\.\s*window\b/g,
+        objc: /\[\s*\[\s*UIApplication\s+sharedApplication\s*\]\s+delegate\s*\]\s*\.\s*window\b|\[\s*UIApplication\s+sharedApplication\s*\]\s*\.\s*delegate\s*\.\s*window\b/g,
+        inAppDelegateOnly: false,
+    },
+    'app-delegate-window': {
+        // Reading the root view controller of the app delegate's own window; assigning it is SCN002.
+        swift: /(?<![\w.])(?:self\s*\.\s*)?window\s*[?!]\s*\.\s*rootViewController\b(?!\s*=[^=])/g,
+        objc: /\bself\s*\.\s*window\s*\.\s*rootViewController\b(?!\s*=[^=])|\[\s*self\.window\s+rootViewController\s*\]/g,
+        inAppDelegateOnly: true,
+    },
+};
+/** The app delegate creating a window of its own. */
+export const WINDOW_CREATION = {
+    swift: /\bUIWindow\s*\(\s*frame\s*:/g,
+    objc: /\[\s*\[\s*UIWindow\s+alloc\s*\]\s*initWithFrame\s*:/g,
+};
+/** An app delegate that supplies scene configurations in code. */
+export const CONFIGURATION_FOR_CONNECTING = {
+    swift: /\bfunc\s+application\s*\([^)]*\bconfigurationForConnecting\b/,
+    objc: /\bconfigurationForConnectingSceneSession\s*:/,
+};
+//# sourceMappingURL=patterns.js.map

package/dist/rules/query.d.ts

@@ -0,0 +1,16 @@
+import { type AppModel, type AppTarget } from '../collect/app.js';
+import { type SourceFile } from '../collect/sources.js';
+export interface Match {
+    file: SourceFile;
+    offset: number;
+}
+export declare function matches(files: readonly SourceFile[], pattern: (file: SourceFile) => RegExp | null): Generator<{
+    file: SourceFile;
+    offset: number;
+}, void, unknown>;
+export declare function inAppDelegate(app: AppModel, match: Match): boolean;
+export declare function sceneDelegateText(app: AppModel): string;
+export declare const isSwiftUIApp: (app: AppModel) => boolean;
+/** Whether a target gets a scene configuration from its Info.plist or the app delegate. */
+export declare function adoptsScenes(app: AppModel, target: AppTarget): boolean;
+export declare function appDelegateName(app: AppModel): string;

package/dist/rules/query.js

@@ -0,0 +1,50 @@
+// Questions the rules ask about an app's sources: where a pattern matches, whether a match is in
+// an app delegate, and whether the app gets a scene configuration at all.
+import { sceneManifest } from '../collect/app.js';
+import { insideTypeNamed } from '../collect/sources.js';
+import { CONFIGURATION_FOR_CONNECTING } from './patterns.js';
+export function* matches(files, pattern) {
+    for (const file of files) {
+        const regex = pattern(file);
+        if (!regex)
+            continue;
+        const global = regex.global ? regex : new RegExp(regex.source, `${regex.flags}g`);
+        global.lastIndex = 0;
+        for (let match = global.exec(file.code); match; match = global.exec(file.code)) {
+            // Skip leading whitespace that a multiline pattern may have consumed.
+            const offset = match.index + (match[0].length - match[0].trimStart().length);
+            yield { file, offset };
+            if (match[0].length === 0)
+                global.lastIndex++;
+        }
+    }
+}
+export function inAppDelegate(app, match) {
+    return insideTypeNamed(app.sources, match.file, match.offset, app.sources.appDelegates);
+}
+export function sceneDelegateText(app) {
+    return app.sources.regions
+        .filter((region) => app.sources.sceneDelegates.has(region.name))
+        .map((region) => region.file.code.slice(region.start, region.end))
+        .join('\n');
+}
+export const isSwiftUIApp = (app) => app.sources.swiftUIApps.some((region) => region.main);
+function implementsConfigurationForConnecting(app) {
+    for (const match of matches(app.sources.files, (file) => CONFIGURATION_FOR_CONNECTING[file.language])) {
+        if (inAppDelegate(app, match))
+            return true;
+    }
+    return false;
+}
+/** Whether a target gets a scene configuration from its Info.plist or the app delegate. */
+export function adoptsScenes(app, target) {
+    if (isSwiftUIApp(app))
+        return true;
+    if (target.infoPlists.some((plist) => sceneManifest(plist).configured))
+        return true;
+    return implementsConfigurationForConnecting(app);
+}
+export function appDelegateName(app) {
+    return [...app.sources.appDelegates][0] ?? 'the app delegate';
+}
+//# sourceMappingURL=query.js.map

package/dist/scan.d.ts

@@ -0,0 +1,10 @@
+import { type Finding, type Report, type Verdict } from './model.js';
+import { type RuleData } from './rules/data.js';
+export interface ScanOptions {
+    /** Rule data to use instead of the bundled rules/ios27.json (tests). */
+    data?: RuleData;
+}
+/** One sentence that answers "will it launch?" for the findings. */
+export declare function verdictOf(findings: readonly Finding[], data: RuleData): Verdict;
+/** Checks the project at `path` (a folder, or an .xcodeproj) and returns the report. */
+export declare function scan(path: string, options?: ScanOptions): Promise<Report>;

package/dist/scan.js

@@ -0,0 +1,115 @@
+// scan(): detect the project, collect its app, run the rules and build the report.
+import { relative, sep } from 'node:path';
+import { collectApp } from './collect/app.js';
+import { detectProject } from './detect/project.js';
+import { SCHEMA_VERSION, } from './model.js';
+import { adoptsScenes, checkApp } from './rules/check.js';
+import { loadRuleData } from './rules/data.js';
+import { VERSION } from './version.js';
+const toPosix = (path) => path.split(sep).join('/');
+function lifecycleOf(app, target) {
+    if (app.sources.swiftUIApps.some((region) => region.main))
+        return 'swiftui';
+    if (adoptsScenes(app, target))
+        return 'scenes';
+    return target.infoPlistSource === 'not-read' ? 'unknown' : 'app-delegate';
+}
+function versionsOf(app) {
+    const versions = [...app.project.packages.values()].map((entry) => ({
+        name: entry.name,
+        version: entry.version,
+        source: entry.source,
+    }));
+    if (app.project.flutter) {
+        versions.unshift({
+            name: 'flutter',
+            version: app.project.flutter.version,
+            source: app.project.flutter.version ? 'pinned' : 'not pinned',
+        });
+    }
+    return versions;
+}
+/** One sentence that answers "will it launch?" for the findings. */
+export function verdictOf(findings, data) {
+    const open = findings.filter((item) => !item.mitigation);
+    const blocking = open.find((item) => item.rule === 'SCN001' && item.severity === 'error');
+    if (blocking) {
+        return { code: 'fails-to-launch', text: 'Fails to launch when built with the iOS 27 SDK.' };
+    }
+    const mitigated = findings.find((item) => item.rule === 'SCN001' && item.mitigation);
+    if (mitigated?.mitigation) {
+        return {
+            code: 'launches-through-workaround',
+            text: `Launches through ${mitigated.mitigation.package}, a run-time workaround; the app itself does not adopt scenes.`,
+        };
+    }
+    const unchecked = open.find((item) => item.rule === 'SCN001' && item.severity === 'info');
+    if (unchecked) {
+        return {
+            code: 'unknown',
+            text: `Launch not determined: sdkbump could not read the Info.plist of ${unchecked.target ?? 'the app'}.`,
+        };
+    }
+    const hasScenesAndOwnWindow = open.some((item) => item.rule === 'SCN002') && !findings.some((item) => item.rule === 'SCN001');
+    if (hasScenesAndOwnWindow) {
+        return {
+            code: 'black-screen',
+            text: 'Launches to a black screen: the app delegate creates a window that belongs to no scene.',
+        };
+    }
+    if (open.length > 0) {
+        return {
+            code: 'review',
+            text: `Launches; ${open.length} ${open.length === 1 ? 'finding' : 'findings'} to review.`,
+        };
+    }
+    return {
+        code: 'no-findings',
+        text: `No findings for the checks in ${data.ruleSet}@${data.dataVersion}.`,
+    };
+}
+/** Checks the project at `path` (a folder, or an .xcodeproj) and returns the report. */
+export async function scan(path, options = {}) {
+    const data = options.data ?? loadRuleData();
+    const project = await detectProject(path);
+    const app = await collectApp(project);
+    const display = (absolute) => toPosix(relative(project.root, absolute)) || '.';
+    const findings = (await checkApp(app, data)).map(({ path: file, ...rest }) => ({
+        ...rest,
+        file: display(file),
+    }));
+    const targets = app.targets.map((target) => ({
+        name: target.name,
+        lifecycle: lifecycleOf(app, target),
+        infoPlists: target.infoPlists.map((plist) => display(plist.path)),
+        infoPlistSource: target.infoPlistSource,
+    }));
+    const notes = app.notes.map((note) => note.split(`${project.root}${sep}`).join(''));
+    const installed = data.workarounds.filter((workaround) => project.packages.has(workaround.package));
+    if (installed.length > 1) {
+        notes.push(`${installed.map((workaround) => workaround.package).join(' and ')} are both installed; their READMEs say to use one or the other.`);
+    }
+    const count = (severity) => findings.filter((item) => item.severity === severity && !item.mitigation).length;
+    return {
+        schemaVersion: SCHEMA_VERSION,
+        tool: { name: 'sdkbump', version: VERSION },
+        rules: { ruleSet: data.ruleSet, dataVersion: data.dataVersion, sdk: data.sdk },
+        project: {
+            path,
+            name: project.name,
+            ecosystem: project.ecosystem,
+            versions: versionsOf(app),
+            targets,
+        },
+        verdict: verdictOf(findings, data),
+        findings,
+        notes,
+        summary: {
+            errors: count('error'),
+            warnings: count('warning'),
+            info: count('info'),
+            mitigated: findings.filter((item) => item.mitigation).length,
+        },
+    };
+}
+//# sourceMappingURL=scan.js.map

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** Version of the installed sdkbump package, read from its package.json. */
+export declare const VERSION: string;