@tantawowa/hosanna-tools 3.20.0 → 3.22.0

package/README.md

@@ -350,6 +350,8 @@ Bare `hst run` in an interactive terminal discovers runnable web previews, vendo
 
 `browser` is the canonical public platform; legacy platform input `web` is normalized to `browser`. `emulator` is the public desktop-preview target and HST retains internal target kind `web`. For Tizen and webOS, emulator mode launches the target-specific Vite config so compile-time initializers are selected; it is not a vendor simulator. `--target sim` launches a real vendor virtual device only for supported Apple/Android platforms. `--target device` launches or deploys to physical local hardware. Device/sim runs record the target and refuse to overwrite a recorded session or safe-to-kill occupied resource in non-interactive mode unless `--replace` is passed. Tizen/webOS previews cannot reuse a Browser session because their compiled alias graphs differ. Preferred run defaults live in `.hosanna-tools/run.json`, and friendly device aliases live in `.hosanna-tools/devices.json` or `~/.hosanna-tools/devices.json`; signing keys and device passphrases remain in vendor stores.
 
+HST starts new Android virtual devices with the Android Emulator's recommended `auto` graphics mode. Set `HS_ANDROID_EMULATOR_GPU` to an emulator-supported mode such as `host` or `software` when a machine needs an explicit performance or compatibility override. HST reads this setting only when it starts the AVD; stop and restart an already-running emulator through HST after changing it. The value is passed directly to the installed emulator, so its available modes remain authoritative.
+
 ### Roku Commands (`roku:*`) - Roku Deployment & Packaging
 - `roku:run` - Deploy a Roku app to a device (supports .zip file or folder)
 - `roku:command` - Send a Hosanna command to an installed channel through Roku ECP
@@ -666,7 +668,7 @@ Screenshots and proofs wait for the command-plane hierarchy and focus to remain
 
 Custom test ports must be unique. Keep the Vite and browser CDP ports outside the debugger's dynamic app allocation range; the launcher validates this before starting any processes and reports the conflicting range.
 
-Keep structural and state assertions as the default correctness checks. Use `hs.screenshot.match(...)` only for an explicit visual regression whose target-specific baseline and tolerance are intentionally maintained. Failure diagnostics and proof artifacts are separated below `test-results/<testRunId>/<platform>-<target>/`.
+Keep structural and state assertions as the default correctness checks. Use `hs.screenshot.match(...)` only for an explicit visual regression whose target-specific baseline and tolerance are intentionally maintained. Set `HS_UPDATE_SCREENSHOTS=1` only after reviewing a candidate: update mode creates missing baselines, replaces existing baselines even when the old comparison differs, and treats the captured frame as the new passing expectation. Failure diagnostics and proof artifacts are separated below `test-results/<testRunId>/<platform>-<target>/`.
 
 `buildConfig` supplies a non-secret overlay that is merged last for the owned test launch. It may be a target-aware factory, so browser emulation can enable deterministic mocks while a physical Roku keeps its real platform services. The launcher and resolver both reject test overlays for `prod`:
 

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "buildDate": "2026-08-20T09:22:08+00:00",
-  "buildDateISO": "2026-08-20T09:22:08.268Z",
+  "buildDate": "2026-08-21T18:58:20+00:00",
+  "buildDateISO": "2026-08-21T18:58:20.482Z",
   "timeZone": "UTC",
-  "gitHash": "195e8ff"
+  "gitHash": "cb698c6"
 }

package/dist/native/native-project.js

@@ -12,10 +12,11 @@ exports.formatNativeDoctorReportText = formatNativeDoctorReportText;
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const minimatch_1 = require("minimatch");
 const DEFAULT_REFERENCE_ROOT = 'hosanna-ui';
 const RUN_CONFIG_PATH = '.hosanna-tools/run.json';
 const METADATA_PATH = '.hosanna-tools/native-project.json';
-const TEMPLATE_VERSION = 'app-owned-native-v9-project-managed-gradle-wrapper';
+const TEMPLATE_VERSION = 'app-owned-native-v10-tvos-debug-overlay-input-capture';
 const ANIMATED_IMAGE_TEMPLATE_VERSION = 8;
 const ANIMATED_IMAGE_MIGRATION_PATHS = [
     'platforms/apple/project.yml',
@@ -28,6 +29,16 @@ const PROJECT_MANAGED_GRADLE_WRAPPER_MIGRATION_PATHS = [
     'platforms/android/gradle/wrapper/gradle-wrapper.jar',
     'platforms/android/gradle/wrapper/gradle-wrapper.properties',
 ];
+const TVOS_DEBUG_OVERLAY_CAPTURE_TEMPLATE_VERSION = 10;
+const APPLE_PROJECT_PATH = 'platforms/apple/project.yml';
+const TVOS_ROOT_HOST_PATH = 'platforms/apple/hosanna-apple/HosannaTvApp.swift';
+const TVOS_LEGACY_HOST_PATH = 'platforms/apple/hosanna-apple/src/app/RootViewController.swift';
+const TVOS_ROOT_HOST_SOURCE_PATH = 'hosanna-apple/HosannaTvApp.swift';
+const TVOS_LEGACY_ENTRY_POINT_PATH = 'platforms/apple/hosanna-apple/src/app/AppDelegate.swift';
+const TVOS_LEGACY_ENTRY_POINT_SOURCE_PATH = 'hosanna-apple/src/app/AppDelegate.swift';
+const TVOS_DEBUG_OVERLAY_CAPTURE_MIGRATION_PATHS = [
+    TVOS_ROOT_HOST_PATH,
+];
 const NATIVE_PLATFORM_ORDER = [
     'ios',
     'apple-tv',
@@ -93,6 +104,14 @@ function createNativeInitPlan(input) {
     const isConfiguringAndroidAutoMedia = identity.androidAutoMediaBrowserService !== undefined;
     const animatedImageMigrationPaths = animatedImageManagedMigrationPaths(existingMetadata);
     const projectManagedGradleWrapperMigrationPaths = managedMigrationPaths(existingMetadata, PROJECT_MANAGED_GRADLE_WRAPPER_MIGRATION_PATHS, PROJECT_MANAGED_GRADLE_WRAPPER_TEMPLATE_VERSION);
+    const currentAppleTvHostSelection = readAppleTvHostSelection(cwd);
+    const willReplaceAppleProject = Boolean(input.replace)
+        || isAddingPlatform
+        || animatedImageMigrationPaths.includes(APPLE_PROJECT_PATH);
+    const shouldMigrateRootTvHost = willReplaceAppleProject
+        || !currentAppleTvHostSelection.legacyConfigured
+        || currentAppleTvHostSelection.rootConfigured;
+    const tvosDebugOverlayCaptureMigrationPaths = managedMigrationPaths(existingMetadata, shouldMigrateRootTvHost ? TVOS_DEBUG_OVERLAY_CAPTURE_MIGRATION_PATHS : [], TVOS_DEBUG_OVERLAY_CAPTURE_TEMPLATE_VERSION);
     const legacySymlinks = createLegacySymlinkPlan(cwd, referenceRoot, requestedPlatforms, errors);
     validatePlatformRoots(cwd, requestedPlatforms, existingMetadata, errors);
     const definitions = createTemplateDefinitions(cwd, referenceRoot, referenceRootInput, managedPlatforms, identity);
@@ -109,6 +128,7 @@ function createNativeInitPlan(input) {
                 : []),
             ...animatedImageMigrationPaths,
             ...projectManagedGradleWrapperMigrationPaths,
+            ...tvosDebugOverlayCaptureMigrationPaths,
         ],
         referenceRootInput,
         platforms: managedPlatforms,
@@ -117,6 +137,7 @@ function createNativeInitPlan(input) {
         appendAndroidAutoMediaPreservationWarnings(projectFiles, warnings);
     }
     appendAnimatedImageDependencyWarnings(projectFiles, warnings);
+    appendTvOsDebugOverlayCaptureWarnings(cwd, projectFiles, requestedPlatforms, warnings);
     const directories = createDirectoryPlan(cwd, projectFiles);
     const editableFiles = projectFiles.filter(item => isEditableProjectFile(item.path));
     const gitignore = createGitignorePlan(cwd);
@@ -212,6 +233,7 @@ function createNativeDoctorReport(input) {
     const missing = [];
     const errors = [...plan.errors];
     const animatedImageIssues = animatedImageDependencyIssues(plan.projectFiles);
+    const tvosDebugOverlayCaptureIssues = tvOsDebugOverlayCaptureIssues(plan.cwd, plan.projectFiles, plan.requestedPlatforms);
     if (!fs_1.default.existsSync(plan.referenceRoot)) {
         errors.push(`Reference root ${relative(plan.cwd, plan.referenceRoot)} does not exist. Run hst sdk:install before building native targets.`);
     }
@@ -225,12 +247,16 @@ function createNativeDoctorReport(input) {
             errors.push(`${item.path} is a legacy whole-directory symlink. Run ${fixCommand(input.platform)} to migrate it to an app-owned thin project.`);
         }
     }
+    const hasReadableMetadata = readNativeProjectMetadata(plan.cwd) !== undefined;
     for (const item of plan.projectFiles) {
         if (item.action !== 'preserve') {
+            if (item.path === METADATA_PATH && item.action === 'replace' && hasReadableMetadata) {
+                continue;
+            }
             missing.push(item.path);
         }
     }
-    errors.push(...animatedImageIssues);
+    errors.push(...animatedImageIssues, ...tvosDebugOverlayCaptureIssues);
     return {
         schemaVersion: 1,
         cwd: plan.cwd,
@@ -239,7 +265,7 @@ function createNativeDoctorReport(input) {
         ok: missing.length === 0 && errors.length === 0,
         fixCommand: fixCommand(input.platform),
         missing,
-        warnings: plan.warnings.filter(warning => !animatedImageIssues.includes(warning)),
+        warnings: plan.warnings.filter(warning => (!animatedImageIssues.includes(warning) && !tvosDebugOverlayCaptureIssues.includes(warning))),
         errors,
     };
 }
@@ -643,6 +669,295 @@ function countOccurrences(content, fragment) {
         return 0;
     return content.split(fragment).length - 1;
 }
+function appendTvOsDebugOverlayCaptureWarnings(cwd, projectFiles, platforms, warnings) {
+    warnings.push(...tvOsDebugOverlayCaptureIssues(cwd, projectFiles, platforms));
+}
+function tvOsDebugOverlayCaptureIssues(cwd, projectFiles, platforms) {
+    if (!platforms.includes('apple-tv'))
+        return [];
+    const appleProjectItem = projectFiles.find(file => file.path === APPLE_PROJECT_PATH);
+    if (!appleProjectItem || !fs_1.default.existsSync(appleProjectItem.absolutePath))
+        return [];
+    const selection = readAppleTvHostSelection(cwd);
+    if (selection.rootConfigured && selection.legacyConfigured) {
+        return [
+            `Apple TV target hosanna-apple in ${APPLE_PROJECT_PATH} compiles both ${TVOS_ROOT_HOST_SOURCE_PATH} and legacy hosanna-apple/src/app, creating multiple @main entry points. Keep exactly one host: retain \`- path: hosanna-apple/src/app\` and remove or exclude ${TVOS_ROOT_HOST_SOURCE_PATH} for the legacy UIKit host, or retain \`- path: ${TVOS_ROOT_HOST_SOURCE_PATH}\` and remove or exclude legacy src/app for the SwiftUI host; then rerun \`hst native:doctor apple\`.`,
+        ];
+    }
+    if (!selection.rootConfigured && !selection.legacyConfigured) {
+        return [
+            `Apple TV target hosanna-apple in ${APPLE_PROJECT_PATH} does not compile a supported app host. Configure exactly one of \`- path: ${TVOS_ROOT_HOST_SOURCE_PATH}\` or \`- path: hosanna-apple/src/app\`, then rerun \`hst native:doctor apple\`.`,
+        ];
+    }
+    const hostPath = selection.rootConfigured ? TVOS_ROOT_HOST_PATH : TVOS_LEGACY_HOST_PATH;
+    const absoluteHostPath = path_1.default.join(cwd, hostPath);
+    if (!fs_1.default.existsSync(absoluteHostPath)) {
+        return [
+            `Apple TV target hosanna-apple selects ${hostPath}, but that host file does not exist. Restore the selected host or update ${APPLE_PROJECT_PATH} to compile the other supported host; then rerun \`hst native:doctor apple\`.`,
+        ];
+    }
+    const hostContent = fs_1.default.readFileSync(absoluteHostPath, 'utf8');
+    if (!satisfiesTvOsDebugOverlayCaptureContract(hostContent)) {
+        const mergeGuidance = selection.rootConfigured
+            ? `Manually merge the current HosannaTvApp.swift template's per-UIPress debugOverlayCaptureRouteByPress routing into the compiled host.`
+            : `Merge per-UIPress debug-overlay routing into RootViewController.swift: Play/Pause and captured presses must go directly to RemoteProcessor without entering super.presses* or pressesForJS, and pressesCancelled must release the latched route.`;
+        return [
+            `Apple TV debug-overlay input capture is incomplete in the host actually compiled by ${APPLE_PROJECT_PATH}: ${hostPath}. ${mergeGuidance} This keeps Play/Pause remote-only and prevents a capture change during a five-second Play/Pause hold from splitting the UIKit lifecycle; then rerun \`hst native:doctor apple\`.`,
+        ];
+    }
+    return [];
+}
+function satisfiesTvOsDebugOverlayCaptureContract(content) {
+    const routeFunction = swiftBracedSlice(content, 'func routePresses');
+    const beginsLifecycleBranch = routeFunction
+        ? swiftBracedSlice(routeFunction, 'if beginsLifecycle')
+        : undefined;
+    if (!(beginsLifecycleBranch === null || beginsLifecycleBranch === void 0 ? void 0 : beginsLifecycleBranch.includes('debugOverlayCaptureRouteByPress[identifier] = routeToDebugOverlay'))) {
+        return false;
+    }
+    const requiredFragments = [
+        { value: 'private var debugOverlayCaptureRouteByPress: [ObjectIdentifier: Bool] = [:]' },
+        { value: 'routePresses(presses, beginsLifecycle: true)' },
+        { value: 'routePresses(presses, beginsLifecycle: false)', count: 2 },
+        { value: 'press.type == .playPause' },
+        { value: 'RemoteProcessor.isDebugOverlayInputCaptured' },
+        { value: 'debugOverlayCaptureRouteByPress[identifier] = routeToDebugOverlay' },
+        { value: 'debugOverlayCaptureRouteByPress.removeValue(forKey: identifier)' },
+        { value: 'override func pressesCancelled' },
+    ];
+    if (!requiredFragments.every(fragment => {
+        var _a;
+        return (countOccurrences(content, fragment.value) >= ((_a = fragment.count) !== null && _a !== void 0 ? _a : 1));
+    })) {
+        return false;
+    }
+    return [
+        {
+            name: 'pressesBegan',
+            beginsLifecycle: true,
+            capturedDispatch: 'remoteProcessor?.handlePresses(routed.captured, pressed: true)',
+        },
+        {
+            name: 'pressesEnded',
+            beginsLifecycle: false,
+            capturedDispatch: 'remoteProcessor?.handlePresses(routed.captured, pressed: false)',
+        },
+        {
+            name: 'pressesCancelled',
+            beginsLifecycle: false,
+            capturedDispatch: 'remoteProcessor?.handlePressesCancelled(routed.captured)',
+        },
+    ].every(handler => tvOsPressHandlerSatisfiesCaptureContract(content, handler));
+}
+function tvOsPressHandlerSatisfiesCaptureContract(content, handler) {
+    const handlerSlice = swiftOverrideFunctionSlice(content, handler.name);
+    if (!handlerSlice)
+        return false;
+    const routeCall = `routePresses(presses, beginsLifecycle: ${handler.beginsLifecycle})`;
+    if (!handlerSlice.includes(routeCall) || !handlerSlice.includes(handler.capturedDispatch))
+        return false;
+    if (handler.name === 'pressesCancelled' && /\.handlePresses\s*\(/.test(handlerSlice))
+        return false;
+    // The captured set may only be inspected for emptiness and dispatched directly
+    // to RemoteProcessor. Any other use can leak it back into UIKit or native-control
+    // filtering, including union/mixed expressions that start with routed.normal.
+    const unaccountedCapturedUses = handlerSlice
+        .split(handler.capturedDispatch).join('')
+        .split('routed.captured.isEmpty').join('');
+    if (unaccountedCapturedUses.includes('routed.captured'))
+        return false;
+    const forwardedArguments = [
+        ...firstArgumentsForCalls(handlerSlice, `super.${handler.name}`),
+        ...firstArgumentsForCalls(handlerSlice, 'pressesForJS'),
+    ];
+    return forwardedArguments.every(argument => !/\bpresses\b/.test(argument));
+}
+function swiftOverrideFunctionSlice(content, functionName) {
+    return swiftBracedSlice(content, `override func ${functionName}`);
+}
+function swiftBracedSlice(content, marker) {
+    const functionStart = content.indexOf(marker);
+    if (functionStart < 0)
+        return undefined;
+    const bodyStart = content.indexOf('{', functionStart + marker.length);
+    if (bodyStart < 0)
+        return undefined;
+    let depth = 0;
+    for (let index = bodyStart; index < content.length; index += 1) {
+        if (content[index] === '{') {
+            depth += 1;
+        }
+        else if (content[index] === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return content.slice(functionStart, index + 1);
+        }
+    }
+    return undefined;
+}
+function firstArgumentsForCalls(content, callName) {
+    var _a;
+    const argumentsFound = [];
+    let searchFrom = 0;
+    while (searchFrom < content.length) {
+        const callStart = content.indexOf(callName, searchFrom);
+        if (callStart < 0)
+            break;
+        let openingParenthesis = callStart + callName.length;
+        while (/\s/.test((_a = content[openingParenthesis]) !== null && _a !== void 0 ? _a : ''))
+            openingParenthesis += 1;
+        if (content[openingParenthesis] !== '(') {
+            searchFrom = openingParenthesis;
+            continue;
+        }
+        let nestedParentheses = 0;
+        let argumentEnd = -1;
+        for (let index = openingParenthesis + 1; index < content.length; index += 1) {
+            if (content[index] === '(') {
+                nestedParentheses += 1;
+            }
+            else if (content[index] === ')') {
+                if (nestedParentheses === 0) {
+                    argumentEnd = index;
+                    break;
+                }
+                nestedParentheses -= 1;
+            }
+            else if (content[index] === ',' && nestedParentheses === 0) {
+                argumentEnd = index;
+                break;
+            }
+        }
+        if (argumentEnd < 0)
+            break;
+        argumentsFound.push(content.slice(openingParenthesis + 1, argumentEnd).trim());
+        searchFrom = argumentEnd + 1;
+    }
+    return argumentsFound;
+}
+function readAppleTvHostSelection(cwd) {
+    const projectPath = path_1.default.join(cwd, APPLE_PROJECT_PATH);
+    if (!fs_1.default.existsSync(projectPath)) {
+        return { projectExists: false, rootConfigured: false, legacyConfigured: false };
+    }
+    const entries = appleTvSourceEntries(fs_1.default.readFileSync(projectPath, 'utf8'));
+    const legacyEntryPointExists = fs_1.default.existsSync(path_1.default.join(cwd, TVOS_LEGACY_ENTRY_POINT_PATH));
+    const legacyConfigured = entries.some(entry => (sourceEntryCompilesFile(entry, TVOS_LEGACY_ENTRY_POINT_SOURCE_PATH)
+        && (legacyEntryPointExists || explicitlySelectsLegacyHost(entry.path))));
+    return {
+        projectExists: true,
+        rootConfigured: entries.some(entry => sourceEntryCompilesFile(entry, TVOS_ROOT_HOST_SOURCE_PATH)),
+        legacyConfigured,
+    };
+}
+function explicitlySelectsLegacyHost(sourcePath) {
+    const normalized = normalizeAppleSourcePath(sourcePath);
+    return normalized === 'hosanna-apple/src/app'
+        || normalized.startsWith('hosanna-apple/src/app/');
+}
+function appleTvSourceEntries(content) {
+    const targetLines = appleTvTargetBlock(content).split(/\r?\n/);
+    const sourcesIndex = targetLines.findIndex(line => /^\s*sources:\s*(?:#.*)?$/.test(line));
+    if (sourcesIndex < 0)
+        return [];
+    const sourcesIndent = indentation(targetLines[sourcesIndex]);
+    const sourceBlock = [];
+    for (let index = sourcesIndex + 1; index < targetLines.length; index += 1) {
+        const line = targetLines[index];
+        if (line.trim() && !line.trimStart().startsWith('#') && indentation(line) <= sourcesIndent)
+            break;
+        sourceBlock.push(line);
+    }
+    const candidateRows = sourceBlock
+        .map((line, index) => ({ line, index, indent: indentation(line) }))
+        .filter(row => /^\s*-\s+(?:path:\s*)?[^#\s]/.test(row.line) && row.indent > sourcesIndent);
+    if (candidateRows.length === 0)
+        return [];
+    const entryIndent = Math.min(...candidateRows.map(row => row.indent));
+    const entryRows = candidateRows.filter(row => row.indent === entryIndent);
+    return entryRows.flatMap((row, entryIndex) => {
+        var _a, _b;
+        const nextIndex = (_b = (_a = entryRows[entryIndex + 1]) === null || _a === void 0 ? void 0 : _a.index) !== null && _b !== void 0 ? _b : sourceBlock.length;
+        const entryBlock = sourceBlock.slice(row.index, nextIndex);
+        const sourcePath = parseSourceEntryPath(row.line);
+        if (!sourcePath)
+            return [];
+        return [{ path: sourcePath, excludes: parseSourceEntryExcludes(entryBlock) }];
+    });
+}
+function parseSourceEntryPath(line) {
+    const value = line.replace(/^\s*-\s+/, '');
+    const pathValue = value.startsWith('path:') ? value.slice('path:'.length) : value;
+    const parsed = parseYamlScalar(pathValue);
+    return parsed && !parsed.includes(':') ? parsed : undefined;
+}
+function parseSourceEntryExcludes(lines) {
+    const excludesIndex = lines.findIndex(line => /^\s*excludes:\s*(?:#.*)?$/.test(line));
+    if (excludesIndex < 0)
+        return [];
+    const excludesIndent = indentation(lines[excludesIndex]);
+    const excludes = [];
+    for (let index = excludesIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line.trim() && !line.trimStart().startsWith('#') && indentation(line) <= excludesIndent)
+            break;
+        const match = /^\s*-\s+(.+?)\s*$/.exec(line);
+        if (!match)
+            continue;
+        const value = parseYamlScalar(match[1]);
+        if (value)
+            excludes.push(value);
+    }
+    return excludes;
+}
+function parseYamlScalar(value) {
+    let normalized = value.trim();
+    if (!normalized)
+        return undefined;
+    const quote = normalized[0];
+    if ((quote === '"' || quote === "'") && normalized.lastIndexOf(quote) > 0) {
+        return normalized.slice(1, normalized.lastIndexOf(quote));
+    }
+    const commentIndex = normalized.indexOf(' #');
+    if (commentIndex >= 0)
+        normalized = normalized.slice(0, commentIndex).trimEnd();
+    return normalized || undefined;
+}
+function sourceEntryCompilesFile(entry, sourceFile) {
+    const sourcePath = normalizeAppleSourcePath(entry.path);
+    const normalizedFile = normalizeAppleSourcePath(sourceFile);
+    const relativeFile = normalizedFile === sourcePath
+        ? path_1.default.posix.basename(normalizedFile)
+        : normalizedFile.startsWith(`${sourcePath}/`)
+            ? normalizedFile.slice(sourcePath.length + 1)
+            : undefined;
+    if (relativeFile === undefined)
+        return false;
+    return !entry.excludes.some(pattern => (0, minimatch_1.minimatch)(relativeFile, normalizeAppleSourcePath(pattern), { dot: true }));
+}
+function normalizeAppleSourcePath(value) {
+    return value.replaceAll('\\', '/').replace(/^\.\//, '').replace(/\/$/, '');
+}
+function appleTvTargetBlock(content) {
+    const lines = content.split(/\r?\n/);
+    const targetIndex = lines.findIndex(line => /^\s+hosanna-apple:\s*(?:#.*)?$/.test(line));
+    if (targetIndex < 0)
+        return '';
+    const targetIndent = indentation(lines[targetIndex]);
+    let endIndex = lines.length;
+    for (let index = targetIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line.trim() && !line.trimStart().startsWith('#') && indentation(line) <= targetIndent) {
+            endIndex = index;
+            break;
+        }
+    }
+    return lines.slice(targetIndex, endIndex).join('\n');
+}
+function indentation(line) {
+    var _a, _b;
+    return (_b = (_a = /^\s*/.exec(line)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+}
 function appendAndroidAutoMediaPreservationWarnings(projectFiles, warnings) {
     const configuredFiles = [
         [