semantifold 0.4.0 → 0.5.0

package/build/src/backends/android.js

@@ -0,0 +1,1274 @@
+// @ts-check
+import { createHash } from "node:crypto";
+import { isDenseArray } from "../array.js";
+import { findPortableArtifactPathConflict, isSafeArtifactPath } from "../artifact-path.js";
+import { createByteMapping } from "../binary-mapping.js";
+import { SemantifoldDiagnostic, unsupportedCapability } from "../diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { preflightSemanticProgram } from "./program.js";
+import { emitScalarType } from "./scalars.js";
+import { kotlinRuntime } from "./kotlin-runtime.js";
+import { emitKotlinBlock } from "./kotlin.js";
+import { SourceWriter } from "./writer.js";
+const projectRoot = "generated/android-app";
+const generatorVersion = "0.4.0";
+/** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
+const androidSourceLanguages = new Set([
+    "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart"
+]);
+const requestFields = new Set(["assets", "configuration", "language", "module", "program", "resources", "role"]);
+const configurationFields = new Set([
+    "activityClassName", "applicationId", "buildToolsVersion", "compileSdk", "displayName", "minimumSdk", "namespace",
+    "orientation", "packageName", "permissions", "productName", "targetSdk", "theme", "versionCode", "versionName"
+]);
+const resourceFields = new Set(["content", "mediaType", "path", "sha256"]);
+const kotlinKeywords = new Set([
+    "as", "break", "class", "continue", "do", "else", "false", "for", "fun", "if", "in", "interface", "is", "null",
+    "object", "package", "return", "super", "this", "throw", "true", "try", "typealias", "typeof", "val", "var", "when", "while"
+]);
+const androidScaffoldSymbols = new Set([
+    "Activity", "Base64", "Bundle", "IllegalStateException", "Instrumentation", "Intent", "R", "SemantifoldEntryTest",
+    "SemantifoldUiInstrumentation", "StandardCharsets", "String", "SuppressLint", "Test", "TextView", "Throwable", "View"
+]);
+const mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+(?:;[\u0020-\u007e]+)?$/u;
+const semanticVersionPattern = /^(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)(?:-(?:0|[1-9][0-9]*|[A-Za-z-][A-Za-z0-9-]*)(?:\.(?:0|[1-9][0-9]*|[A-Za-z-][A-Za-z0-9-]*))*)?(?:\+[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*)?$/u;
+const toolchain = Object.freeze({
+    androidGradlePlugin: "8.11.1",
+    archives: {
+        buildTools: {
+            revision: "35.0.0",
+            sha256: "bd3a4966912eb8b30ed0d00b0cda6b6543b949d5ffe00bea54c04c81e1561d88",
+            url: "https://dl.google.com/android/repository/build-tools_r35_linux.zip"
+        },
+        commandLineTools: {
+            revision: "11076708",
+            sha256: "2d2d50857e4eb553af5a6dc3ad507a17adf43d115264b1afc116f95c92e5e258",
+            url: "https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip"
+        },
+        emulator: {
+            buildId: "13610412",
+            revision: "35.6.11",
+            sha256: "2fe2b56fe93ce75e1d478a40162131381d911c355efeaedb54dd1e0d0897a5cf",
+            url: "https://edgedl.me.gvt1.com/edgedl/android/repository/emulator-linux_x64-13610412.zip"
+        },
+        platform: {
+            revision: "35-r2",
+            sha256: "0988cacad01b38a18a47bac14a0695f246bc76c1b06c0eeb8eb0dc825ab0c8e0",
+            url: "https://dl.google.com/android/repository/platform-35_r02.zip"
+        },
+        platformTools: {
+            revision: "37.0.1",
+            sha256: "d230f13842f60f782a8645f9c813f8f845bf36089ea7289f28c48f17979313f1",
+            url: "https://dl.google.com/android/repository/platform-tools_r37.0.1-linux.zip"
+        },
+        systemImage: {
+            revision: "35-google_apis-x86_64-r9",
+            sha256: "c67b9ba0ff5bc0eb6d046871bfa228af14d4d47b02f0cdae94f048e511b7566e",
+            url: "https://dl.google.com/android/repository/sys-img/google_apis/x86_64-35_r09.zip"
+        }
+    },
+    buildTools: "35.0.0",
+    commandLineTools: "11076708",
+    compileSdk: 35,
+    emulator: "35.6.11",
+    gradle: "8.13",
+    java: "21.0.8",
+    kotlin: "2.2.10",
+    kotlinCompilerSha256: "302d1d8e671e5c3207e6ed62ff11fb555462a628e22a1158254dcaaf7e7394bc",
+    systemImage: "system-images;android-35;google_apis;x86_64",
+    targetSdk: 35
+});
+const excludedPathPatterns = Object.freeze([".gradle/**", "**/build/**", "local.properties"]);
+const androidKotlinRuntime = `@file:Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
+
+package __PACKAGE__.semantic
+
+${kotlinRuntime.replaceAll("private ", "internal ")}
+internal class SemantifoldOutputSink {
+  private val values: java.util.ArrayList<String> = java.util.ArrayList<String>()
+
+  fun reset() {
+    values.clear()
+  }
+
+  fun write(value: Long) {
+    values.add(value.toString())
+  }
+
+  fun write(value: Boolean) {
+    values.add(if (value) "true" else "false")
+  }
+
+  fun write(value: String) {
+    values.add(value)
+  }
+
+  fun snapshot(): java.util.ArrayList<String> = java.util.ArrayList<String>(values)
+}
+`;
+/** @typedef {{content: string | Uint8Array, contentKind: "binary" | "text", fullPath: string, mediaType: string, path: string, sha256: string}} AndroidInputFile */
+/** @typedef {{end: number, field: string, path: string, start: number}} ConfigurationSpan */
+/**
+ * Preflights a complete Android application request before allocating a source writer.
+ * @param {Record<string, unknown>} input - Candidate application request.
+ * @returns {{assets: AndroidInputFile[], configuration: import("../semantic/types.js").AndroidApplicationConfiguration, modulePaths: Map<string, string>, modules: import("../semantic/types.js").SemanticModule[], packagePath: string, program: import("../semantic/types.js").SemanticProgram, resources: AndroidInputFile[], sources: {content: string, filename: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} Prepared application.
+ */
+export function preflightAndroidApplication(input) {
+    if (!isPlainObject(input) || Object.keys(input).some(key => !requestFields.has(key)) ||
+        Boolean(input.module) == Boolean(input.program)) {
+        invalidInput("Android application generation requires a closed request with exactly one semantic module or program.");
+    }
+    if (input.language !== undefined && input.language != "android" || input.role !== undefined && input.role != "application") {
+        invalidInput("Android application generation accepts only the Android application role.");
+    }
+    const configuration = normalizeConfiguration(input.configuration);
+    const program = input.program ?? normalizeSingleModule(
+    /** @type {import("../semantic/types.js").SemanticModule | undefined} */ (input.module));
+    const prepared = preflightSemanticProgram({
+        backendLanguage: "kotlin",
+        diagnosticLanguage: "android",
+        program: /** @type {import("../semantic/types.js").SemanticProgram} */ (program),
+        sourceLanguages: androidSourceLanguages
+    });
+    validateActivityClassName(configuration.activityClassName, prepared.program.entryModule);
+    const packagePath = configuration.packageName.replaceAll(".", "/");
+    const semanticRoot = `${projectRoot}/app/src/main/kotlin/${packagePath}/semantic`;
+    const modulePaths = new Map(prepared.modules.map(module => [
+        /** @type {string} */ (Reflect.get(module, "id")),
+        `${semanticRoot}/${moduleName(/** @type {string} */ (Reflect.get(module, "id")))}.kt`
+    ]));
+    const resources = normalizeInputFiles(input.resources, "resource");
+    const assets = normalizeInputFiles(input.assets, "asset");
+    const fixedPaths = applicationPaths(configuration, modulePaths);
+    const completePaths = [
+        ...fixedPaths,
+        ...resources.map(({ fullPath }) => fullPath),
+        ...assets.map(({ fullPath }) => fullPath)
+    ];
+    const conflict = findPortableArtifactPathConflict(completePaths);
+    if (conflict) {
+        invalidPath(`Application artifact path '${conflict.path}' has a ${conflict.kind} conflict${conflict.other ? ` with '${conflict.other}'` : ""}.`);
+    }
+    return { ...prepared, assets, configuration, modulePaths, packagePath, resources };
+}
+/**
+ * Generates one complete deterministic Android/Kotlin project.
+ * @param {Record<string, unknown>} input - Application generation request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], metadata: {applicationManifest: string, platformQualification: string}, target: "android"}} Candidate artifact set.
+ */
+export function generateAndroidApplication(input) {
+    const prepared = preflightAndroidApplication(input);
+    const configurationSpans = /** @type {ConfigurationSpan[]} */ ([]);
+    const configuration = prepared.configuration;
+    const packagePath = prepared.packagePath;
+    const semanticArtifacts = renderSemanticArtifacts(prepared);
+    const artifacts = /** @type {import("../semantic/types.js").GeneratedSetArtifact[]} */ ([
+        configuredText(`${projectRoot}/app/build.gradle.kts`, "manifest", renderAppBuild(configuration, configurationSpans), "Pinned dependency-minimal Android application build."),
+        configuredText(`${projectRoot}/app/src/androidTest/AndroidManifest.xml`, "manifest", renderAndroidTestManifest(configuration, configurationSpans), "Platform-only Android instrumentation declaration."),
+        configuredText(`${projectRoot}/app/src/androidTest/kotlin/${packagePath}/SemantifoldUiInstrumentation.kt`, "support", renderInstrumentation(configuration, configurationSpans), "Platform-only accessibility and lifecycle assertion."),
+        configuredText(`${projectRoot}/app/src/main/AndroidManifest.xml`, "manifest", renderAndroidManifest(configuration, configurationSpans), "Closed allowlisted Android application manifest."),
+        configuredText(`${projectRoot}/app/src/main/kotlin/${packagePath}/${configuration.activityClassName}.kt`, "entry", renderActivity(configuration, prepared.program.entryModule, configurationSpans), "Synthetic Android activity lifecycle and native output view binding."),
+        ...semanticArtifacts,
+        syntheticText(`${projectRoot}/app/src/main/res/layout/activity_main.xml`, "resource", renderLayout(), "Synthetic one-view Android layout and accessibility identity."),
+        configuredText(`${projectRoot}/app/src/main/res/values/strings.xml`, "resource", renderStrings(configuration, configurationSpans), "Escaped application labels derived from configuration."),
+        syntheticText(`${projectRoot}/app/src/main/res/values/themes.xml`, "resource", renderTheme(), "Closed platform-native application theme."),
+        syntheticText(`${projectRoot}/app/src/main/res/xml/backup_rules.xml`, "resource", renderBackupRules(), "Closed API 23-30 full-backup exclusions."),
+        syntheticText(`${projectRoot}/app/src/main/res/xml/data_extraction_rules.xml`, "resource", renderDataExtractionRules(), "Closed Android 12+ cloud-backup and device-transfer exclusions."),
+        configuredText(`${projectRoot}/app/src/test/kotlin/${packagePath}/SemantifoldEntryTest.kt`, "support", renderUnitTest(configuration, prepared.program.entryModule, configurationSpans), "JUnit test-scope-only semantic determinism assertion."),
+        syntheticText(`${projectRoot}/build.gradle.kts`, "manifest", renderRootBuild(), "Pinned Android and Kotlin build plugins."),
+        syntheticText(`${projectRoot}/gradle.properties`, "support", renderGradleProperties(), "Pinned hermetic Gradle process properties."),
+        configuredText(`${projectRoot}/settings.gradle.kts`, "manifest", renderSettings(configuration, configurationSpans), "Closed official Gradle plugin and dependency repositories."),
+        ...prepared.resources.map(inputFileArtifact),
+        ...prepared.assets.map(inputFileArtifact)
+    ]);
+    artifacts.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+    const manifestPath = `${projectRoot}/semantifold-project.json`;
+    artifacts.push(syntheticText(manifestPath, "manifest", renderProjectManifest(prepared, artifacts, manifestPath, configurationSpans), "Versioned Android project ownership, toolchain, and provenance manifest."));
+    return {
+        artifacts,
+        metadata: { applicationManifest: manifestPath, platformQualification: "tensorbuzz-kvm" },
+        target: "android"
+    };
+}
+/**
+ * Renders the mapped semantic Kotlin artifacts for every program module.
+ * @param {ReturnType<typeof preflightAndroidApplication>} prepared - Prepared application.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact[]} Semantic Kotlin artifacts.
+ */
+function renderSemanticArtifacts(prepared) {
+    const semanticRoot = `${projectRoot}/app/src/main/kotlin/${prepared.packagePath}/semantic`;
+    /** @type {import("../semantic/types.js").GeneratedSetArtifact[]} */
+    const artifacts = [syntheticText(`${semanticRoot}/SemantifoldRuntime.kt`, "support", androidKotlinRuntime.replaceAll("__PACKAGE__", prepared.configuration.packageName), "Shared Android application output capture and checked Kotlin scalar support.")];
+    const declarations = new Map();
+    for (const module of prepared.modules) {
+        for (const declaration of module.functions)
+            declarations.set(declaration.id, {
+                declaration,
+                moduleId: /** @type {string} */ (Reflect.get(module, "id"))
+            });
+    }
+    for (const module of prepared.modules) {
+        const moduleId = /** @type {string} */ (Reflect.get(module, "id"));
+        const filename = /** @type {string} */ (prepared.modulePaths.get(moduleId));
+        const sinkName = outputSinkName(module);
+        const writer = new SourceWriter({
+            callArgumentSuffix: sinkName,
+            callNameResolver: expression => {
+                const resolved = declarations.get(expression.resolution?.declarationId);
+                if (!resolved)
+                    throw new TypeError(`Unknown validated Android function '${expression.resolution?.declarationId}'.`);
+                return `SemantifoldModule${moduleName(resolved.moduleId)}.${resolved.declaration.name}`;
+            },
+            filename,
+            language: "kotlin",
+            methodStringEquality: true,
+            module,
+            program: prepared.program,
+            programPaths: prepared.modulePaths,
+            sources: prepared.sources
+        });
+        writer.synthetic(`@file:Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")\n\npackage ${prepared.configuration.packageName}.semantic\n\n`, "Android semantic package namespace", [module], [""]);
+        emitSemanticModule(writer, module, moduleId, moduleId == prepared.program.entryModule, sinkName);
+        const mapping = finalizeMapping(writer.finish());
+        artifacts.push({
+            content: mapping.generated.content,
+            contentKind: "text",
+            mediaType: "text/x-kotlin",
+            ownership: "generated",
+            path: filename,
+            provenance: { kind: "text", mapping, sourceMap: toSourceMapV3(mapping), sourceMapFilename: `${filename}.map` },
+            role: "source"
+        });
+    }
+    return artifacts;
+}
+/**
+ * Emits one namespaced semantic module and its entry bridge when applicable.
+ * @param {SourceWriter} writer - Mapped Kotlin writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Prepared module.
+ * @param {string} moduleId - Stable module identity.
+ * @param {boolean} entry - Whether this module owns the entry block.
+ * @param {string} sinkName - Collision-safe output sink binding.
+ */
+function emitSemanticModule(writer, module, moduleId, entry, sinkName) {
+    writer.synthetic(`internal object SemantifoldModule${moduleName(moduleId)} {\n`, "Android semantic module namespace", [module], [""]);
+    module.functions.forEach((declaration, functionIndex) => {
+        const path = `/functions/${functionIndex}`;
+        writer.synthetic("  ", "Android namespaced function indentation", [declaration], [path]);
+        writer.mapped("fun", { mappingKind: "anchor", node: declaration, path });
+        writer.synthetic(" ", "declaration spacing", [declaration], [path]);
+        writer.mapped(declaration.name, { mappingKind: "exact", node: declaration, path, role: "name" });
+        writer.synthetic("(", "function parameter scaffold", [declaration], [path]);
+        declaration.parameters.forEach((parameter, parameterIndex) => {
+            const parameterPath = `${path}/parameters/${parameterIndex}`;
+            if (parameterIndex)
+                writer.synthetic(", ", "parameter separator", [parameter], [parameterPath]);
+            writer.mapped(parameter.name, { mappingKind: "exact", node: parameter, path: parameterPath, role: "name" });
+            writer.synthetic(": ", "parameter annotation scaffold", [parameter], [parameterPath]);
+            writer.mapped(emitScalarType("kotlin", parameter.type), { mappingKind: "exact", node: parameter.type,
+                path: `${parameterPath}/type`, role: "type" });
+        });
+        if (declaration.parameters.length)
+            writer.synthetic(", ", "output sink parameter separator", [declaration], [path]);
+        writer.synthetic(`${sinkName}: SemantifoldOutputSink): `, "shared Android output sink parameter", [declaration], [path]);
+        writer.mapped(emitScalarType("kotlin", declaration.returnType), { mappingKind: "exact", node: declaration.returnType,
+            path: `${path}/returnType`, role: "type" });
+        writer.synthetic(" {\n", "Kotlin function body scaffold", [declaration], [path]);
+        emitKotlinBlock(writer, declaration.body, "    ", `${path}/body`, `${sinkName}.write`);
+        writer.synthetic("  }\n", "Kotlin function body scaffold", [declaration], [path]);
+    });
+    if (entry) {
+        writer.synthetic("  fun semantifoldEntry(): java.util.ArrayList<String> {\n", "Android semantic entry scaffold", [module.entryPoint], ["/entryPoint"]);
+        writer.synthetic(`    val ${sinkName} = SemantifoldOutputSink()\n`, "Android output sink allocation", [module.entryPoint], ["/entryPoint"]);
+        writer.synthetic(`    ${sinkName}.reset()\n`, "Android lifecycle-safe output reset", [module.entryPoint], ["/entryPoint"]);
+        emitKotlinBlock(writer, module.entryPoint.body, "    ", "/entryPoint/body", `${sinkName}.write`);
+        writer.synthetic(`    return ${sinkName}.snapshot()\n`, "Android semantic output return", [module.entryPoint], ["/entryPoint"]);
+        writer.synthetic("  }\n", "Android semantic entry scaffold", [module.entryPoint], ["/entryPoint"]);
+    }
+    writer.synthetic("}\n", "Android semantic module namespace", [module], [""]);
+}
+/**
+ * Lists every fixed generated path before any writer is allocated.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized application configuration.
+ * @param {Map<string, string>} modulePaths - Semantic module output paths.
+ * @returns {string[]} Fixed owned artifact paths.
+ */
+function applicationPaths(configuration, modulePaths) {
+    const packagePath = configuration.packageName.replaceAll(".", "/");
+    return [
+        `${projectRoot}/app/build.gradle.kts`,
+        `${projectRoot}/app/src/androidTest/AndroidManifest.xml`,
+        `${projectRoot}/app/src/androidTest/kotlin/${packagePath}/SemantifoldUiInstrumentation.kt`,
+        `${projectRoot}/app/src/main/AndroidManifest.xml`,
+        `${projectRoot}/app/src/main/kotlin/${packagePath}/${configuration.activityClassName}.kt`,
+        ...modulePaths.values(),
+        `${projectRoot}/app/src/main/kotlin/${packagePath}/semantic/SemantifoldRuntime.kt`,
+        `${projectRoot}/app/src/main/res/layout/activity_main.xml`,
+        `${projectRoot}/app/src/main/res/values/strings.xml`,
+        `${projectRoot}/app/src/main/res/values/themes.xml`,
+        `${projectRoot}/app/src/main/res/xml/backup_rules.xml`,
+        `${projectRoot}/app/src/main/res/xml/data_extraction_rules.xml`,
+        `${projectRoot}/app/src/test/kotlin/${packagePath}/SemantifoldEntryTest.kt`,
+        `${projectRoot}/build.gradle.kts`,
+        `${projectRoot}/gradle.properties`,
+        `${projectRoot}/settings.gradle.kts`,
+        `${projectRoot}/semantifold-project.json`
+    ];
+}
+/**
+ * Renders the pinned root plugin declarations.
+ * @returns {string} Root Gradle Kotlin script.
+ */
+function renderRootBuild() {
+    return `plugins {
+  id("com.android.application") version "${toolchain.androidGradlePlugin}" apply false
+  id("org.jetbrains.kotlin.android") version "${toolchain.kotlin}" apply false
+}
+`;
+}
+/**
+ * Renders closed project settings and repositories.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.
+ * @returns {string} Settings Gradle Kotlin script.
+ */
+function renderSettings(configuration, spans) {
+    return configured(`${projectRoot}/settings.gradle.kts`, spans, [`pluginManagement {
+  repositories {
+    google()
+    mavenCentral()
+    gradlePluginPortal()
+  }
+}
+
+dependencyResolutionManagement {
+  repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+  repositories {
+    google()
+    mavenCentral()
+  }
+}
+
+rootProject.name = "`, field("productName", kotlinEscape(configuration.productName)), `"
+include(":app")
+`]);
+}
+/**
+ * Renders deterministic Gradle process properties.
+ * @returns {string} Gradle properties file.
+ */
+function renderGradleProperties() {
+    return `org.gradle.caching=false
+org.gradle.configuration-cache=false
+org.gradle.daemon=false
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 -Duser.language=en -Duser.country=US -Duser.timezone=UTC
+org.gradle.parallel=false
+kotlin.stdlib.default.dependency=false
+kotlin.code.style=official
+`;
+}
+/**
+ * Renders the application module build contract.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.
+ * @returns {string} Application Gradle Kotlin script.
+ */
+function renderAppBuild(configuration, spans) {
+    return configured(`${projectRoot}/app/build.gradle.kts`, spans, [
+        `import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
+
+plugins {
+  id("com.android.application")
+  id("org.jetbrains.kotlin.android")
+}
+
+dependencies {
+  testRuntimeOnly("org.hamcrest:hamcrest-core:1.3") {
+    isTransitive = false
+  }
+}
+
+val semantifoldKotlinHome = providers.environmentVariable("SEMANTIFOLD_KOTLIN_HOME").orNull
+  ?: throw GradleException("SEMANTIFOLD_ANDROID_INFRASTRUCTURE: SEMANTIFOLD_KOTLIN_HOME is required")
+val semantifoldKotlinStdlib = file("$semantifoldKotlinHome/lib/kotlin-stdlib.jar")
+if (!semantifoldKotlinStdlib.isFile) {
+  throw GradleException("SEMANTIFOLD_ANDROID_INFRASTRUCTURE: pinned Kotlin compile library is missing")
+}
+val semantifoldAcceptanceRoot = providers.environmentVariable("SEMANTIFOLD_ANDROID_ACCEPTANCE_ROOT").orNull
+  ?: throw GradleException("SEMANTIFOLD_ANDROID_INFRASTRUCTURE: SEMANTIFOLD_ANDROID_ACCEPTANCE_ROOT is required")
+val semantifoldDebugKeystore = file("$semantifoldAcceptanceRoot/debug.keystore")
+if (!semantifoldDebugKeystore.isFile) {
+  throw GradleException("SEMANTIFOLD_ANDROID_INFRASTRUCTURE: ephemeral debug keystore is missing")
+}
+
+android {
+  namespace = "`,
+        field("namespace", configuration.namespace), `"\n  compileSdk = `, field("compileSdk", String(configuration.compileSdk)),
+        `\n  buildToolsVersion = "`, field("buildToolsVersion", configuration.buildToolsVersion), `"\n\n  defaultConfig {\n    applicationId = "`,
+        field("applicationId", configuration.applicationId), `"\n    minSdk = `, field("minimumSdk", String(configuration.minimumSdk)),
+        `\n    targetSdk = `, field("targetSdk", String(configuration.targetSdk)), `\n    versionCode = `,
+        field("versionCode", String(configuration.versionCode)), `\n    versionName = "`, field("versionName", kotlinEscape(configuration.versionName)),
+        `"\n    testApplicationId = "`, field("applicationId", configuration.applicationId),
+        `.test"\n    testInstrumentationRunner = "`, field("packageName", configuration.packageName),
+        `.SemantifoldUiInstrumentation"\n  }\n\n  signingConfigs {\n    getByName("debug") {\n      storeFile = semantifoldDebugKeystore\n      storePassword = "android"\n      keyAlias = "androiddebugkey"\n      keyPassword = "android"\n    }\n  }\n  buildTypes {\n    getByName("debug") {\n      signingConfig = signingConfigs.getByName("debug")\n    }\n  }\n  buildFeatures {\n    buildConfig = false\n  }\n  compileOptions {\n    sourceCompatibility = JavaVersion.VERSION_21\n    targetCompatibility = JavaVersion.VERSION_21\n  }\n  lint {\n    abortOnError = true\n    checkDependencies = true\n    disable += "MissingApplicationIcon"\n    disable += "OldTargetApi"\n    disable += "GradleDependency"\n    warningsAsErrors = true\n  }\n  packaging {\n    resources.excludes += setOf("META-INF/LICENSE*", "META-INF/NOTICE*")\n  }\n}\n\ntasks.withType<KotlinJvmCompile>().configureEach {\n  libraries.from(files(semantifoldKotlinStdlib))\n  compilerOptions {\n    allWarningsAsErrors.set(true)\n    freeCompilerArgs.addAll("-Xno-call-assertions", "-Xno-param-assertions", "-Xno-receiver-assertions")\n    jvmTarget.set(JvmTarget.JVM_21)\n  }\n}\n\ndependencies {\n  testImplementation("junit:junit:4.13.2") {\n    isTransitive = false\n  }\n}\n`
+    ]);
+}
+/**
+ * Renders the allowlisted Android application manifest.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.
+ * @returns {string} Android application manifest.
+ */
+function renderAndroidManifest(configuration, spans) {
+    const orientation = configuration.orientation == "unspecified" ? "" : ` android:screenOrientation="${configuration.orientation}"`;
+    return configured(`${projectRoot}/app/src/main/AndroidManifest.xml`, spans, [
+        `<?xml version="1.0" encoding="utf-8"?>\n<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n  <application\n    android:allowBackup="false"\n    android:dataExtractionRules="@xml/data_extraction_rules"\n    android:fullBackupContent="@xml/backup_rules"\n    android:label="@string/app_name"\n    android:supportsRtl="true"\n    android:theme="@style/Theme.Semantifold">\n    <activity\n      android:name="`,
+        field("packageName", configuration.packageName), `.`, field("activityClassName", configuration.activityClassName),
+        `"\n      android:exported="true"`,
+        orientation ? field("orientation", orientation) : "", `>\n      <intent-filter>\n        <action android:name="android.intent.action.MAIN" />\n        <category android:name="android.intent.category.LAUNCHER" />\n      </intent-filter>\n    </activity>\n  </application>\n</manifest>\n`
+    ]);
+}
+/**
+ * Renders explicit API 23-30 exclusions for every full-backup storage domain.
+ * @returns {string} Android full-backup rules XML.
+ */
+function renderBackupRules() {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<full-backup-content>
+  <exclude domain="root" path="." />
+  <exclude domain="file" path="." />
+  <exclude domain="database" path="." />
+  <exclude domain="sharedpref" path="." />
+  <exclude domain="external" path="." />
+  <exclude domain="device_root" path="." />
+  <exclude domain="device_file" path="." />
+  <exclude domain="device_database" path="." />
+  <exclude domain="device_sharedpref" path="." />
+</full-backup-content>
+`;
+}
+/**
+ * Renders explicit Android 12+ exclusions for every cloud-backup and device-transfer storage domain.
+ * @returns {string} Android data extraction rules XML.
+ */
+function renderDataExtractionRules() {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<data-extraction-rules>
+  <cloud-backup>
+    <exclude domain="root" path="." />
+    <exclude domain="file" path="." />
+    <exclude domain="database" path="." />
+    <exclude domain="sharedpref" path="." />
+    <exclude domain="external" path="." />
+    <exclude domain="device_root" path="." />
+    <exclude domain="device_file" path="." />
+    <exclude domain="device_database" path="." />
+    <exclude domain="device_sharedpref" path="." />
+  </cloud-backup>
+  <device-transfer>
+    <exclude domain="root" path="." />
+    <exclude domain="file" path="." />
+    <exclude domain="database" path="." />
+    <exclude domain="sharedpref" path="." />
+    <exclude domain="external" path="." />
+    <exclude domain="device_root" path="." />
+    <exclude domain="device_file" path="." />
+    <exclude domain="device_database" path="." />
+    <exclude domain="device_sharedpref" path="." />
+  </device-transfer>
+</data-extraction-rules>
+`;
+}
+/**
+ * Renders the platform-only instrumentation manifest.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.
+ * @returns {string} Android test manifest.
+ */
+function renderAndroidTestManifest(configuration, spans) {
+    return configured(`${projectRoot}/app/src/androidTest/AndroidManifest.xml`, spans, [
+        `<?xml version="1.0" encoding="utf-8"?>\n<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n  <instrumentation\n    android:name="`,
+        field("packageName", configuration.packageName), `.SemantifoldUiInstrumentation"\n    android:targetPackage="`,
+        field("applicationId", xmlEscape(configuration.applicationId)), `" />\n</manifest>\n`
+    ]);
+}
+/**
+ * Renders the synthetic launcher activity.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized configuration.
+ * @param {string} entryModule - Selected semantic entry module identity.
+ * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.
+ * @returns {string} Kotlin launcher activity source.
+ */
+function renderActivity(configuration, entryModule, spans) {
+    const resourceImport = configuration.namespace == configuration.packageName
+        ? []
+        : ["import ", field("namespace", configuration.namespace), ".R\n"];
+    return configured(`${projectRoot}/app/src/main/kotlin/${configuration.packageName.replaceAll(".", "/")}/${configuration.activityClassName}.kt`, spans, [
+        "package ", field("packageName", configuration.packageName), `
+
+import android.app.Activity
+import android.annotation.SuppressLint
+import android.os.Bundle
+import android.widget.TextView
+`, ...resourceImport, `import `, field("packageName", configuration.packageName),
+        `.semantic.SemantifoldModule${moduleName(entryModule)}
+
+class `, field("activityClassName", configuration.activityClassName), ` : Activity() {
+  @SuppressLint("SetTextI18n")
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.activity_main)
+    val lines = SemantifoldModule${moduleName(entryModule)}.semantifoldEntry()
+    val output = java.lang.StringBuilder()
+    var index = 0
+    while (index < lines.size) {
+      if (index > 0) output.append('\\n')
+      output.append(lines[index])
+      index += 1
+    }
+    findViewById<TextView>(R.id.semantifold_output).text = output.toString()
+  }
+}
+`
+    ]);
+}
+/**
+ * Renders the single accessibility-important native text view.
+ * @returns {string} Android layout XML.
+ */
+function renderLayout() {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<TextView xmlns:android="http://schemas.android.com/apk/res/android"
+  android:id="@+id/semantifold_output"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:gravity="center"
+  android:importantForAccessibility="yes"
+  android:textIsSelectable="true" />
+`;
+}
+/**
+ * Renders configuration-derived string resources.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.
+ * @returns {string} Android string resource XML.
+ */
+function renderStrings(configuration, spans) {
+    return configured(`${projectRoot}/app/src/main/res/values/strings.xml`, spans, [
+        `<?xml version="1.0" encoding="utf-8"?>\n<resources>\n  <string name="app_name">`,
+        field("displayName", xmlEscape(configuration.displayName)), `</string>\n</resources>\n`
+    ]);
+}
+/**
+ * Renders the fixed platform-native baseline theme.
+ * @returns {string} Android theme resource XML.
+ */
+function renderTheme() {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <style name="Theme.Semantifold" parent="android:style/Theme.Material.Light.NoActionBar">
+    <item name="android:fontFamily">sans</item>
+    <item name="android:windowActionModeOverlay">true</item>
+  </style>
+</resources>
+`;
+}
+/**
+ * Renders the sole JUnit test-scope semantic assertion.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized configuration.
+ * @param {string} entryModule - Selected semantic entry module identity.
+ * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.
+ * @returns {string} Kotlin unit test source.
+ */
+function renderUnitTest(configuration, entryModule, spans) {
+    return configured(`${projectRoot}/app/src/test/kotlin/${configuration.packageName.replaceAll(".", "/")}/SemantifoldEntryTest.kt`, spans, [
+        "package ", field("packageName", configuration.packageName), `
+
+import `, field("packageName", configuration.packageName), `.semantic.SemantifoldModule${moduleName(entryModule)}
+import org.junit.Test
+
+class SemantifoldEntryTest {
+  @Test
+  fun entryIsDeterministicAcrossFreshRuns() {
+    val firstOutput = SemantifoldModule${moduleName(entryModule)}.semantifoldEntry()
+    val secondOutput = SemantifoldModule${moduleName(entryModule)}.semantifoldEntry()
+    if (!firstOutput.equals(secondOutput)) {
+      throw AssertionError("Semantic entry output differs across fresh runs.")
+    }
+  }
+}
+`
+    ]);
+}
+/**
+ * Renders the framework-only instrumentation runner.
+ * @param {import("../semantic/types.js").AndroidApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.
+ * @returns {string} Kotlin instrumentation source.
+ */
+function renderInstrumentation(configuration, spans) {
+    const resourceImport = configuration.namespace == configuration.packageName
+        ? []
+        : ["import ", field("namespace", configuration.namespace), ".R\n"];
+    return configured(`${projectRoot}/app/src/androidTest/kotlin/${configuration.packageName.replaceAll(".", "/")}/SemantifoldUiInstrumentation.kt`, spans, [
+        "package ", field("packageName", configuration.packageName), `
+
+import android.app.Activity
+import android.app.Instrumentation
+import android.content.Intent
+import android.os.Bundle
+import android.util.Base64
+import android.view.View
+import android.widget.TextView
+import java.nio.charset.StandardCharsets
+`, ...resourceImport, `
+class SemantifoldUiInstrumentation : Instrumentation() {
+  private var inputArguments: Bundle? = null
+
+  override fun onCreate(arguments: Bundle?) {
+    inputArguments = arguments
+    start()
+  }
+
+  override fun onStart() {
+    try {
+      val providedArguments = inputArguments
+        ?: throw IllegalStateException("missing instrumentation arguments")
+      val encoded = providedArguments.getString("expected_output_base64")
+        ?: throw IllegalStateException("missing expected_output_base64 instrumentation argument")
+      val expected = String(Base64.decode(encoded, Base64.NO_WRAP), StandardCharsets.UTF_8)
+      val launch = targetContext.packageManager.getLaunchIntentForPackage(targetContext.packageName)
+        ?: throw IllegalStateException("generated application has no launcher intent")
+      launch.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+      val activity = startActivitySync(launch) as `, field("activityClassName", configuration.activityClassName), `
+      assertOutput(activity, expected)
+      val monitor = addMonitor(`, field("activityClassName", configuration.activityClassName), `::class.java.name, null, false)
+      runOnMainSync { activity.recreate() }
+      waitForIdleSync()
+      val recreated = waitForMonitorWithTimeout(monitor, 10_000)
+        ?: throw IllegalStateException("activity was not recreated")
+      assertOutput(recreated, expected)
+      finish(Activity.RESULT_OK, Bundle())
+    } catch (error: Throwable) {
+      val result = Bundle()
+      result.putString("semantifold_failure", android.util.Log.getStackTraceString(error))
+      finish(Activity.RESULT_CANCELED, result)
+    }
+  }
+
+  private fun assertOutput(activity: Activity, expected: String) {
+    waitForIdleSync()
+    val actual = activity.findViewById<TextView>(R.id.semantifold_output)
+      ?: throw IllegalStateException("missing semantifold_output view")
+    if (actual.visibility != View.VISIBLE) throw IllegalStateException("output view is not visible")
+    if (actual.javaClass != TextView::class.java) throw IllegalStateException("output view is not a native TextView")
+    if (!actual.text.toString().equals(expected)) throw IllegalStateException("output text mismatch")
+    if (actual.contentDescription != null) throw IllegalStateException("output content description must stay absent")
+    if (actual.importantForAccessibility != View.IMPORTANT_FOR_ACCESSIBILITY_YES) {
+      throw IllegalStateException("output view is not accessibility-important")
+    }
+  }
+}
+`
+    ]);
+}
+/**
+ * Renders the ownership, toolchain, and provenance manifest.
+ * @param {ReturnType<typeof preflightAndroidApplication>} prepared - Prepared application.
+ * @param {import("../semantic/types.js").GeneratedSetArtifact[]} artifacts - Owned project artifacts.
+ * @param {string} manifestPath - Ownership manifest path.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance spans.
+ * @returns {string} Canonical project manifest JSON.
+ */
+function renderProjectManifest(prepared, artifacts, manifestPath, spans) {
+    const inputPaths = new Set([...prepared.resources, ...prepared.assets].map(({ fullPath }) => fullPath));
+    const semanticArtifacts = artifacts.filter(artifact => artifact.provenance.kind == "text");
+    const ownedPaths = [...artifacts.map(({ path }) => path), manifestPath];
+    return stringifyCanonicalJson({
+        configuration: prepared.configuration,
+        generator: { name: "semantifold", version: generatorVersion },
+        ownership: {
+            excludedPathPatterns,
+            ownedPaths,
+            ownedRoot: projectRoot,
+            sha256: artifacts.map(artifact => ({ path: artifact.path, sha256: hashContent(artifact.content) }))
+        },
+        provenance: {
+            configuration: Object.keys(prepared.configuration).sort().map(fieldName => ({
+                field: fieldName,
+                manifestPointer: `/configuration/${fieldName}`,
+                outputs: configurationOutputs(spans, fieldName)
+            })),
+            inputs: [...prepared.resources, ...prepared.assets].map(item => ({
+                contentKind: item.contentKind,
+                mediaType: item.mediaType,
+                path: item.fullPath,
+                sha256: item.sha256
+            })),
+            semanticSources: prepared.sources.map(source => ({
+                artifacts: semanticArtifacts.filter(artifact => artifact.provenance.kind == "text" &&
+                    artifact.provenance.mapping.spans.some(({ origin }) => originReferencesFilename(origin, source.filename)))
+                    .map(({ path }) => path),
+                filename: source.filename,
+                ...(source.language === undefined ? {} : { language: source.language }),
+                sha256: createHash("sha256").update(source.content).digest("hex")
+            })),
+            syntheticScaffolding: [...artifacts.filter(artifact => artifact.provenance.kind == "synthetic" &&
+                    !inputPaths.has(artifact.path)).map(({ path }) => path), manifestPath]
+        },
+        schema: "SemantifoldAndroidProject",
+        semanticProgram: semanticProgramManifest(prepared),
+        target: "android",
+        toolchain,
+        version: 1
+    });
+}
+/**
+ * Renders semantic module and source identities for the project manifest.
+ * @param {ReturnType<typeof preflightAndroidApplication>} prepared - Prepared application.
+ * @returns {Record<string, unknown>} Semantic program manifest.
+ */
+function semanticProgramManifest(prepared) {
+    const sourceContent = new Map(prepared.sources.map(source => [source.filename, source.content]));
+    const order = new Map(prepared.program.modules.map((module, index) => [module.id, index]));
+    const modules = prepared.program.modules.map(module => {
+        const source = prepared.program.sources.find(candidate => candidate.filename == module.sourceFilename);
+        const content = sourceContent.get(module.sourceFilename);
+        if (!source || content === undefined)
+            throw new TypeError(`Preflighted Android module '${module.id}' lost source ownership.`);
+        return {
+            dependencies: [...new Set(module.imports.map(({ moduleId }) => moduleId))]
+                .sort((left, right) => /** @type {number} */ (order.get(left)) - /** @type {number} */ (order.get(right))),
+            generatedArtifacts: [prepared.modulePaths.get(module.id)],
+            id: module.id,
+            namespace: `SemantifoldModule${moduleName(module.id)}`,
+            source: { filename: source.filename, id: source.id, sha256: createHash("sha256").update(content).digest("hex") }
+        };
+    });
+    const entryId = prepared.program.entryModule;
+    return {
+        entry: {
+            activityArtifact: `${projectRoot}/app/src/main/kotlin/${prepared.packagePath}/${prepared.configuration.activityClassName}.kt`,
+            generatedArtifact: prepared.modulePaths.get(entryId),
+            generatedFunctionIdentity: `SemantifoldModule${moduleName(entryId)}.semantifoldEntry`,
+            moduleId: entryId
+        },
+        modules,
+        schema: "SemantifoldAndroidSemanticProgram",
+        sources: prepared.program.sources.map(source => ({
+            filename: source.filename,
+            id: source.id,
+            language: source.language,
+            moduleIds: modules.filter(module => module.source.filename == source.filename).map(({ id }) => id),
+            ownership: source.ownership ?? "application",
+            sha256: createHash("sha256").update(/** @type {string} */ (sourceContent.get(source.filename))).digest("hex")
+        })),
+        version: 1
+    };
+}
+/**
+ * Validates and normalizes the closed Android configuration.
+ * @param {unknown} candidate - Candidate configuration.
+ * @returns {import("../semantic/types.js").AndroidApplicationConfiguration} Normalized configuration.
+ */
+function normalizeConfiguration(candidate) {
+    if (candidate === undefined)
+        candidate = {};
+    if (!isPlainObject(candidate) || Object.keys(candidate).some(key => !configurationFields.has(key))) {
+        invalidConfiguration("Android application configuration must be a closed plain object.");
+    }
+    const configuration = /** @type {import("../semantic/types.js").AndroidApplicationConfigurationInput} */ (candidate);
+    const applicationId = configuration.applicationId ?? "dev.semantifold.generated";
+    const namespace = configuration.namespace ?? applicationId;
+    const packageName = configuration.packageName ?? namespace;
+    const activityClassName = configuration.activityClassName ?? "MainActivity";
+    const productName = configuration.productName ?? "Semantifold";
+    const displayName = configuration.displayName ?? "Semantifold";
+    const minimumSdk = configuration.minimumSdk ?? 23;
+    const targetSdk = configuration.targetSdk ?? toolchain.targetSdk;
+    const compileSdk = configuration.compileSdk ?? toolchain.compileSdk;
+    const buildToolsVersion = configuration.buildToolsVersion ?? toolchain.buildTools;
+    const versionCode = configuration.versionCode ?? 1;
+    const versionName = configuration.versionName ?? "1.0.0";
+    const orientation = configuration.orientation ?? "unspecified";
+    const theme = configuration.theme ?? "system";
+    for (const [label, value] of [["Application ID", applicationId], ["Namespace", namespace], ["Package name", packageName]]) {
+        if (typeof value != "string" || !isPackageName(value))
+            invalidConfiguration(`${label} must be a lowercase Java package identity.`);
+    }
+    if (typeof activityClassName != "string" || !/^[A-Z][A-Za-z0-9]*$/u.test(activityClassName) || kotlinKeywords.has(activityClassName)) {
+        invalidConfiguration("Activity class name must be an ASCII upper-camel Kotlin identifier.");
+    }
+    for (const [label, value] of [["Product name", productName], ["Display name", displayName]]) {
+        if (typeof value != "string" || value.length == 0 || value.trim() != value || [...value].length > 64 ||
+            !hasOnlyUnicodeScalars(value) || /[\p{Cc}\p{Zl}\p{Zp}\uFFFE\uFFFF]/u.test(value)) {
+            invalidConfiguration(`${label} must be a non-empty single-line Unicode scalar string of at most 64 characters.`);
+        }
+    }
+    if (/[\\/:<>"?*|]/u.test(productName)) {
+        invalidConfiguration("Product name contains a character forbidden by the Gradle project-name contract.");
+    }
+    if (minimumSdk !== 23 || targetSdk !== 35 || compileSdk !== 35 || minimumSdk > targetSdk || targetSdk > compileSdk) {
+        invalidConfiguration("SDK levels must use the qualified minimum 23, target 35, and compile 35 matrix.");
+    }
+    if (buildToolsVersion != toolchain.buildTools)
+        invalidConfiguration("Build Tools version must be exactly '35.0.0'.");
+    if (!Number.isSafeInteger(versionCode) || versionCode < 1 || versionCode > 2_100_000_000) {
+        invalidConfiguration("Version code must be a positive Android-safe integer.");
+    }
+    if (typeof versionName != "string" || !semanticVersionPattern.test(versionName)) {
+        invalidConfiguration("Version name must be a canonical non-empty semantic version string.");
+    }
+    if (orientation != "unspecified")
+        invalidConfiguration("The baseline orientation is exactly 'unspecified'.");
+    if (theme != "system")
+        invalidConfiguration("The baseline theme is exactly 'system'.");
+    if (configuration.permissions !== undefined &&
+        (!isDenseArray(configuration.permissions) || configuration.permissions.length != 0)) {
+        invalidConfiguration("The baseline Android permission set must be empty.");
+    }
+    return {
+        activityClassName,
+        applicationId,
+        buildToolsVersion,
+        compileSdk,
+        displayName,
+        minimumSdk,
+        namespace,
+        orientation,
+        packageName,
+        productName,
+        targetSdk,
+        theme,
+        versionCode,
+        versionName
+    };
+}
+/**
+ * Validates, snapshots, and orders caller-provided inputs.
+ * @param {unknown} candidate - Candidate resource or asset list.
+ * @param {"asset" | "resource"} kind - Android input kind.
+ * @returns {AndroidInputFile[]} Normalized inputs.
+ */
+function normalizeInputFiles(candidate, kind) {
+    if (candidate === undefined)
+        return [];
+    if (!isDenseArray(candidate))
+        invalidResource(`Application ${kind}s must be a dense array.`);
+    /** @type {AndroidInputFile[]} */
+    const files = [];
+    for (let index = 0; index < candidate.length; index += 1) {
+        const item = candidate[index];
+        if (!isPlainObject(item) || Object.keys(item).length != resourceFields.size ||
+            Object.keys(item).some(key => !resourceFields.has(key)))
+            invalidResource(`${capitalize(kind)} ${index} must use the closed input schema.`);
+        const path = item.path;
+        const content = item.content;
+        const mediaType = item.mediaType;
+        const sha256 = item.sha256;
+        if (!isSafeArtifactPath(path) || kind == "resource" && !isAllowedResourcePath(path)) {
+            invalidResource(`${capitalize(kind)} ${index} has an unsafe or unsupported path.`);
+        }
+        if (typeof content != "string" && !(content instanceof Uint8Array) || typeof content == "string" &&
+            (content.length == 0 || !hasOnlyUnicodeScalars(content)) || content instanceof Uint8Array && content.byteLength == 0) {
+            invalidResource(`${capitalize(kind)} '${path}' requires non-empty exact content.`);
+        }
+        if (typeof mediaType != "string" || !mediaTypePattern.test(mediaType) || /[\r\n]/u.test(mediaType)) {
+            invalidResource(`${capitalize(kind)} '${path}' requires an explicit valid media type.`);
+        }
+        if (kind == "resource" && path.startsWith("drawable-") && !["image/png", "image/webp"].includes(mediaType)) {
+            invalidResource(`Drawable resource '${path}' must use PNG or WebP media type.`);
+        }
+        const snapshot = typeof content == "string" ? content : new Uint8Array(content);
+        const actualHash = createHash("sha256").update(snapshot).digest("hex");
+        if (typeof sha256 != "string" || !/^[0-9a-f]{64}$/u.test(sha256) || sha256 != actualHash) {
+            invalidResource(`${capitalize(kind)} '${path}' SHA-256 does not match its exact content.`);
+        }
+        const fullPath = `${projectRoot}/app/src/main/${kind == "resource" ? "res" : "assets"}/${path}`;
+        files.push({ content: snapshot, contentKind: typeof snapshot == "string" ? "text" : "binary", fullPath, mediaType, path, sha256 });
+    }
+    files.sort((left, right) => left.fullPath < right.fullPath ? -1 : left.fullPath > right.fullPath ? 1 : 0);
+    const conflict = findPortableArtifactPathConflict(files.map(({ fullPath }) => fullPath));
+    if (conflict)
+        invalidResource(`${capitalize(kind)} path '${conflict.path}' has a ${conflict.kind} conflict.`);
+    if (kind == "resource")
+        validateResourceIdentifiers(files);
+    return files;
+}
+/**
+ * Rejects two files that Android would compile to the same resource identifier in one configuration.
+ * @param {AndroidInputFile[]} files - Validated resource inputs.
+ */
+function validateResourceIdentifiers(files) {
+    const identifiers = new Map();
+    for (const file of files) {
+        const separator = file.path.indexOf("/");
+        const directory = file.path.slice(0, separator);
+        const filename = file.path.slice(separator + 1);
+        const extension = filename.indexOf(".");
+        const name = extension == -1 ? filename : filename.slice(0, extension);
+        const resourceType = directory.split("-", 1)[0];
+        const key = `${directory}/${name}`;
+        const previous = identifiers.get(key);
+        if (previous) {
+            invalidResource(`Android resource identifier '${resourceType}/${name}' collides between '${previous}' and '${file.path}' in configuration '${directory}'.`);
+        }
+        identifiers.set(key, file.path);
+    }
+}
+/**
+ * Tests whether a caller resource uses the narrow allowlisted resource grammar.
+ * @param {string} value - Resource path relative to res.
+ * @returns {boolean} Whether the path is supported.
+ */
+function isAllowedResourcePath(value) {
+    if (/^raw\/[a-z][a-z0-9_]*(?:\.[a-z0-9]+)?$/u.test(value))
+        return true;
+    return /^drawable-(?:mdpi|hdpi|xhdpi|xxhdpi|xxxhdpi)\/[a-z][a-z0-9_]*\.(?:png|webp)$/u.test(value);
+}
+/**
+ * Converts a validated input snapshot into an owned artifact.
+ * @param {AndroidInputFile} item - Validated caller input.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Owned input artifact.
+ */
+function inputFileArtifact(item) {
+    const reason = `Exact caller-provided Android input (sha256:${item.sha256}).`;
+    if (typeof item.content == "string") {
+        return {
+            ...syntheticText(item.fullPath, "resource", item.content, reason),
+            mediaType: item.mediaType
+        };
+    }
+    const content = new Uint8Array(item.content);
+    return {
+        content,
+        contentKind: "binary",
+        mediaType: item.mediaType,
+        ownership: "generated",
+        path: item.fullPath,
+        provenance: { kind: "bytes", mapping: createByteMapping({
+                byteLength: content.byteLength,
+                path: item.fullPath,
+                ranges: [{ generated: { end: content.byteLength, start: 0 },
+                        origin: { kind: "synthetic", reason, relatedOrigins: [] }, role: "resource" }]
+            }) },
+        role: "resource"
+    };
+}
+/**
+ * Creates a deterministic synthetic text artifact.
+ * @param {string} path - Artifact path.
+ * @param {import("../semantic/types.js").GeneratedArtifactRole} role - Artifact role.
+ * @param {string} content - UTF-8 artifact content.
+ * @param {string} reason - Synthetic provenance reason.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Text artifact.
+ */
+function syntheticText(path, role, content, reason) {
+    return { content, contentKind: "text", mediaType: mediaTypeFor(path), ownership: "generated", path,
+        provenance: { kind: "synthetic", reason, relatedOrigins: [] }, role };
+}
+/**
+ * Creates a configuration-derived text artifact.
+ * @param {string} path - Artifact path.
+ * @param {import("../semantic/types.js").GeneratedArtifactRole} role - Artifact role.
+ * @param {string} content - UTF-8 artifact content.
+ * @param {string} reason - Synthetic provenance reason.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Text artifact.
+ */
+function configuredText(path, role, content, reason) {
+    return syntheticText(path, role, content, reason);
+}
+/**
+ * Derives the media type for a generated text path.
+ * @param {string} path - Generated artifact path.
+ * @returns {string} Artifact media type.
+ */
+function mediaTypeFor(path) {
+    if (path.endsWith(".json"))
+        return "application/json";
+    if (path.endsWith(".xml"))
+        return "application/xml";
+    if (path.endsWith(".kt") || path.endsWith(".kts"))
+        return "text/x-kotlin";
+    return "text/plain";
+}
+/**
+ * Marks one rendered value as configuration-derived.
+ * @param {string} fieldName - Configuration field name.
+ * @param {string} value - Rendered field value.
+ * @returns {{field: string, value: string}} Marked configuration value.
+ */
+function field(fieldName, value) {
+    return { field: fieldName, value };
+}
+/**
+ * Joins rendered parts while recording configuration causality.
+ * @param {string} path - Output artifact path.
+ * @param {ConfigurationSpan[]} spans - Mutable provenance span collector.
+ * @param {(string | {field: string, value: string})[]} parts - Synthetic and marked parts.
+ * @returns {string} Rendered text.
+ */
+function configured(path, spans, parts) {
+    let content = "";
+    for (const part of parts) {
+        if (typeof part == "string")
+            content += part;
+        else {
+            const start = content.length;
+            content += part.value;
+            spans.push({ end: content.length, field: part.field, path, start });
+        }
+    }
+    return content;
+}
+/**
+ * Groups configuration spans by artifact.
+ * @param {ConfigurationSpan[]} spans - All rendered configuration spans.
+ * @param {string} fieldName - Requested configuration field.
+ * @returns {{path: string, ranges: {end: number, start: number}[]}[]} Output ranges.
+ */
+function configurationOutputs(spans, fieldName) {
+    const grouped = new Map();
+    for (const span of spans) {
+        if (span.field != fieldName)
+            continue;
+        const ranges = grouped.get(span.path) ?? [];
+        ranges.push({ end: span.end, start: span.start });
+        grouped.set(span.path, ranges);
+    }
+    return [...grouped].map(([path, ranges]) => ({ path, ranges }));
+}
+/**
+ * Tests whether a mapping origin refers to one semantic source file.
+ * @param {import("../semantic/types.js").SemanticOrigin} origin - Mapping origin.
+ * @param {string} filename - Semantic source filename.
+ * @returns {boolean} Whether the origin owns the filename.
+ */
+function originReferencesFilename(origin, filename) {
+    if (origin.kind == "source")
+        return origin.location.filename == filename;
+    if (origin.kind == "derived")
+        return origin.origins.some(({ location }) => location.filename == filename);
+    return origin.relatedOrigins.some(({ location }) => location.filename == filename);
+}
+/**
+ * Hashes exact text or bytes for ownership records.
+ * @param {string | Uint8Array} content - Exact artifact content.
+ * @returns {string} Lowercase SHA-256 digest.
+ */
+function hashContent(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+/**
+ * Serializes JSON with recursively stable object-key ordering.
+ * @param {unknown} value - JSON-compatible value.
+ * @returns {string} Canonical indented JSON with trailing newline.
+ */
+function stringifyCanonicalJson(value) {
+    return `${JSON.stringify(sortJson(value), null, 2)}\n`;
+}
+/**
+ * Recursively sorts object keys without changing array order.
+ * @param {unknown} value - JSON-compatible value.
+ * @returns {unknown} Canonically ordered value.
+ */
+function sortJson(value) {
+    if (Array.isArray(value))
+        return value.map(sortJson);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.keys(value).sort().map(key => [key, sortJson(value[key])]));
+}
+/**
+ * Tests a lowercase Kotlin-compatible package identity.
+ * @param {string} value - Candidate package name.
+ * @returns {boolean} Whether the name is accepted.
+ */
+function isPackageName(value) {
+    const parts = value.split(".");
+    return parts.length >= 2 && parts.every(part => /^[a-z][a-z0-9_]*$/u.test(part) && !kotlinKeywords.has(part));
+}
+/**
+ * Rejects launcher names that shadow an unqualified symbol in generated same-package Kotlin.
+ * @param {string} activityClassName - Validated launcher class name.
+ * @param {string} entryModule - Selected semantic entry module.
+ */
+function validateActivityClassName(activityClassName, entryModule) {
+    const semanticEntrySymbol = `SemantifoldModule${moduleName(entryModule)}`;
+    if (androidScaffoldSymbols.has(activityClassName) || activityClassName == semanticEntrySymbol) {
+        invalidConfiguration(`Activity class name '${activityClassName}' collides with generated Kotlin symbol '${activityClassName}'.`);
+    }
+}
+/**
+ * Allocates one module-wide output sink that cannot shadow a source binding.
+ * @param {import("../semantic/types.js").SemanticModule} module - Prepared semantic module.
+ * @returns {string} Collision-safe Kotlin binding.
+ */
+function outputSinkName(module) {
+    const bindings = new Set(module.functions.flatMap(declaration => declaration.parameters.map(({ name }) => name)));
+    for (const declaration of module.functions)
+        collectBlockBindingNames(declaration.body, bindings);
+    collectBlockBindingNames(module.entryPoint.body, bindings);
+    let candidate = "semantifoldOutput";
+    while (bindings.has(candidate))
+        candidate += "_";
+    return candidate;
+}
+/**
+ * Collects local bindings recursively from the supported semantic block subset.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {Set<string>} bindings - Mutable binding-name set.
+ */
+function collectBlockBindingNames(block, bindings) {
+    for (const statement of block.statements) {
+        if (statement.kind == "LocalDeclaration")
+            bindings.add(statement.name);
+        else if (statement.kind == "IfStatement") {
+            collectBlockBindingNames(statement.consequent, bindings);
+            if (statement.alternate)
+                collectBlockBindingNames(statement.alternate, bindings);
+        }
+    }
+}
+/**
+ * Maps a preflighted module identity to a stable Kotlin suffix.
+ * @param {string} id - Semantic module identity.
+ * @returns {string} Kotlin object-name suffix.
+ */
+function moduleName(id) {
+    return id.split(/[._-]+/u).map(part => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
+}
+/**
+ * Wraps legacy single-module input in the canonical program contract.
+ * @param {import("../semantic/types.js").SemanticModule | undefined} candidate - Candidate semantic module.
+ * @returns {import("../semantic/types.js").SemanticProgram} Canonical single-module program.
+ */
+function normalizeSingleModule(candidate) {
+    if (!isPlainObject(candidate))
+        unsupportedCapability("android", "missing or invalid module", undefined);
+    const module = structuredClone(candidate);
+    const sources = module.provenance?.sources;
+    if (!Array.isArray(sources) || sources.length != 1 || sources[0].content === null ||
+        sources[0].filename != module.location?.filename || typeof sources[0].language != "string") {
+        unsupportedCapability("android", "single-module source ownership", module.location);
+    }
+    rekeyModuleDeclarations(module, "main");
+    const exports = [
+        ...(module.records ?? []).map(declaration => applicationExport(declaration, "record")),
+        ...(module.classes ?? []).map(declaration => applicationExport(declaration, "class")),
+        ...(module.errors ?? []).map(declaration => applicationExport(declaration, "error")),
+        ...module.functions.map(declaration => applicationExport(declaration, "function"))
+    ];
+    const programModule = { ...module, exports, id: "main", imports: [], sourceFilename: sources[0].filename };
+    return { entryModule: "main", kind: "Program", modules: [programModule], sources: structuredClone(sources) };
+}
+/**
+ * Creates an application-local export record for single-module compatibility.
+ * @param {{id?: string, location: import("../semantic/types.js").SourceLocation, name: string}} declaration - Semantic declaration.
+ * @param {import("../semantic/types.js").SemanticDeclarationKind} symbolKind - Declaration kind.
+ * @returns {import("../semantic/types.js").SemanticExport} Semantic export.
+ */
+function applicationExport(declaration, symbolKind) {
+    return { declarationId: /** @type {string} */ (declaration.id), exportedName: declaration.name,
+        kind: /** @type {const} */ ("Export"), location: declaration.location, symbolKind };
+}
+/**
+ * Qualifies single-module declaration identities before program preflight.
+ * @param {import("../semantic/types.js").SemanticModule} module - Cloned semantic module.
+ * @param {string} moduleId - Canonical module identity.
+ */
+function rekeyModuleDeclarations(module, moduleId) {
+    const declarations = [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions];
+    const replacements = new Map(declarations.filter(declaration => typeof declaration.id == "string")
+        .map(declaration => [declaration.id, `${moduleId}#${declaration.id}`]));
+    for (const declaration of declarations)
+        if (typeof declaration.id == "string")
+            declaration.id = replacements.get(declaration.id);
+    const seen = new Set();
+    const identityFields = new Set(["classId", "declarationId", "field", "method", "parameterId"]);
+    /**
+     * Rewrites declaration references throughout one semantic value graph.
+     * @param {unknown} value - Candidate nested semantic value.
+     */
+    const visit = value => {
+        if (!value || typeof value != "object" || seen.has(value))
+            return;
+        seen.add(value);
+        for (const [key, nested] of Object.entries(value)) {
+            if (!Array.isArray(value) && identityFields.has(key) && typeof nested == "string" && replacements.has(nested)) {
+                Reflect.set(value, key, replacements.get(nested));
+            }
+            else
+                visit(nested);
+        }
+    };
+    visit(module);
+}
+/**
+ * Escapes a configuration value for XML text or attributes.
+ * @param {string} value - Raw configuration value.
+ * @returns {string} XML-safe value.
+ */
+function xmlEscape(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+/**
+ * Escapes a configuration value for a Kotlin string literal body.
+ * @param {string} value - Raw configuration value.
+ * @returns {string} Kotlin-safe value.
+ */
+function kotlinEscape(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("$", "\\$");
+}
+/**
+ * Uppercases the initial ASCII character of a known non-empty word.
+ * @param {string} value - Non-empty word.
+ * @returns {string} Capitalized word.
+ */
+function capitalize(value) {
+    return `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+/**
+ * Tests whether a value is a plain data object.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+    return Boolean(value) && typeof value == "object" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Throws a stable invalid-request diagnostic.
+ * @param {string} message - Diagnostic message.
+ * @returns {never} Never returns.
+ */
+function invalidInput(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_INPUT", language: "android", message });
+}
+/**
+ * Throws a stable invalid-configuration diagnostic.
+ * @param {string} message - Diagnostic message.
+ * @returns {never} Never returns.
+ */
+function invalidConfiguration(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_CONFIGURATION", language: "android", message });
+}
+/**
+ * Throws a stable invalid-resource diagnostic.
+ * @param {string} message - Diagnostic message.
+ * @returns {never} Never returns.
+ */
+function invalidResource(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_RESOURCE", language: "android", message });
+}
+/**
+ * Throws a stable invalid-path diagnostic.
+ * @param {string} message - Diagnostic message.
+ * @returns {never} Never returns.
+ */
+function invalidPath(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_PATH", language: "android", message });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"android.js","sourceRoot":"","sources":["../../../src/backends/android.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport {isDenseArray} from \"../array.js\"\nimport {findPortableArtifactPathConflict, isSafeArtifactPath} from \"../artifact-path.js\"\nimport {createByteMapping} from \"../binary-mapping.js\"\nimport {SemantifoldDiagnostic, unsupportedCapability} from \"../diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {preflightSemanticProgram} from \"./program.js\"\nimport {emitScalarType} from \"./scalars.js\"\nimport {kotlinRuntime} from \"./kotlin-runtime.js\"\nimport {emitKotlinBlock} from \"./kotlin.js\"\nimport {SourceWriter} from \"./writer.js\"\n\nconst projectRoot = \"generated/android-app\"\nconst generatorVersion = \"0.4.0\"\n/** @type {Readonly<Set<import(\"../semantic/types.js\").SemanticLanguage>>} */\nconst androidSourceLanguages = new Set([\n  \"php\", \"ruby\", \"javascript\", \"typescript\", \"java\", \"kotlin\", \"python\", \"csharp\", \"go\", \"c\", \"cpp\", \"rust\", \"swift\", \"dart\"\n])\nconst requestFields = new Set([\"assets\", \"configuration\", \"language\", \"module\", \"program\", \"resources\", \"role\"])\nconst configurationFields = new Set([\n  \"activityClassName\", \"applicationId\", \"buildToolsVersion\", \"compileSdk\", \"displayName\", \"minimumSdk\", \"namespace\",\n  \"orientation\", \"packageName\", \"permissions\", \"productName\", \"targetSdk\", \"theme\", \"versionCode\", \"versionName\"\n])\nconst resourceFields = new Set([\"content\", \"mediaType\", \"path\", \"sha256\"])\nconst kotlinKeywords = new Set([\n  \"as\", \"break\", \"class\", \"continue\", \"do\", \"else\", \"false\", \"for\", \"fun\", \"if\", \"in\", \"interface\", \"is\", \"null\",\n  \"object\", \"package\", \"return\", \"super\", \"this\", \"throw\", \"true\", \"try\", \"typealias\", \"typeof\", \"val\", \"var\", \"when\", \"while\"\n])\nconst androidScaffoldSymbols = new Set([\n  \"Activity\", \"Base64\", \"Bundle\", \"IllegalStateException\", \"Instrumentation\", \"Intent\", \"R\", \"SemantifoldEntryTest\",\n  \"SemantifoldUiInstrumentation\", \"StandardCharsets\", \"String\", \"SuppressLint\", \"Test\", \"TextView\", \"Throwable\", \"View\"\n])\nconst mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\\/[A-Za-z0-9!#$&^_.+-]+(?:;[\\u0020-\\u007e]+)?$/u\nconst semanticVersionPattern = /^(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)(?:-(?:0|[1-9][0-9]*|[A-Za-z-][A-Za-z0-9-]*)(?:\\.(?:0|[1-9][0-9]*|[A-Za-z-][A-Za-z0-9-]*))*)?(?:\\+[A-Za-z0-9-]+(?:\\.[A-Za-z0-9-]+)*)?$/u\nconst toolchain = Object.freeze({\n  androidGradlePlugin: \"8.11.1\",\n  archives: {\n    buildTools: {\n      revision: \"35.0.0\",\n      sha256: \"bd3a4966912eb8b30ed0d00b0cda6b6543b949d5ffe00bea54c04c81e1561d88\",\n      url: \"https://dl.google.com/android/repository/build-tools_r35_linux.zip\"\n    },\n    commandLineTools: {\n      revision: \"11076708\",\n      sha256: \"2d2d50857e4eb553af5a6dc3ad507a17adf43d115264b1afc116f95c92e5e258\",\n      url: \"https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip\"\n    },\n    emulator: {\n      buildId: \"13610412\",\n      revision: \"35.6.11\",\n      sha256: \"2fe2b56fe93ce75e1d478a40162131381d911c355efeaedb54dd1e0d0897a5cf\",\n      url: \"https://edgedl.me.gvt1.com/edgedl/android/repository/emulator-linux_x64-13610412.zip\"\n    },\n    platform: {\n      revision: \"35-r2\",\n      sha256: \"0988cacad01b38a18a47bac14a0695f246bc76c1b06c0eeb8eb0dc825ab0c8e0\",\n      url: \"https://dl.google.com/android/repository/platform-35_r02.zip\"\n    },\n    platformTools: {\n      revision: \"37.0.1\",\n      sha256: \"d230f13842f60f782a8645f9c813f8f845bf36089ea7289f28c48f17979313f1\",\n      url: \"https://dl.google.com/android/repository/platform-tools_r37.0.1-linux.zip\"\n    },\n    systemImage: {\n      revision: \"35-google_apis-x86_64-r9\",\n      sha256: \"c67b9ba0ff5bc0eb6d046871bfa228af14d4d47b02f0cdae94f048e511b7566e\",\n      url: \"https://dl.google.com/android/repository/sys-img/google_apis/x86_64-35_r09.zip\"\n    }\n  },\n  buildTools: \"35.0.0\",\n  commandLineTools: \"11076708\",\n  compileSdk: 35,\n  emulator: \"35.6.11\",\n  gradle: \"8.13\",\n  java: \"21.0.8\",\n  kotlin: \"2.2.10\",\n  kotlinCompilerSha256: \"302d1d8e671e5c3207e6ed62ff11fb555462a628e22a1158254dcaaf7e7394bc\",\n  systemImage: \"system-images;android-35;google_apis;x86_64\",\n  targetSdk: 35\n})\nconst excludedPathPatterns = Object.freeze([\".gradle/**\", \"**/build/**\", \"local.properties\"])\nconst androidKotlinRuntime = `@file:Suppress(\"PLATFORM_CLASS_MAPPED_TO_KOTLIN\")\n\npackage __PACKAGE__.semantic\n\n${kotlinRuntime.replaceAll(\"private \", \"internal \")}\ninternal class SemantifoldOutputSink {\n  private val values: java.util.ArrayList<String> = java.util.ArrayList<String>()\n\n  fun reset() {\n    values.clear()\n  }\n\n  fun write(value: Long) {\n    values.add(value.toString())\n  }\n\n  fun write(value: Boolean) {\n    values.add(if (value) \"true\" else \"false\")\n  }\n\n  fun write(value: String) {\n    values.add(value)\n  }\n\n  fun snapshot(): java.util.ArrayList<String> = java.util.ArrayList<String>(values)\n}\n`\n\n/** @typedef {{content: string | Uint8Array, contentKind: \"binary\" | \"text\", fullPath: string, mediaType: string, path: string, sha256: string}} AndroidInputFile */\n/** @typedef {{end: number, field: string, path: string, start: number}} ConfigurationSpan */\n\n/**\n * Preflights a complete Android application request before allocating a source writer.\n * @param {Record<string, unknown>} input - Candidate application request.\n * @returns {{assets: AndroidInputFile[], configuration: import(\"../semantic/types.js\").AndroidApplicationConfiguration, modulePaths: Map<string, string>, modules: import(\"../semantic/types.js\").SemanticModule[], packagePath: string, program: import(\"../semantic/types.js\").SemanticProgram, resources: AndroidInputFile[], sources: {content: string, filename: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} Prepared application.\n */\nexport function preflightAndroidApplication(input) {\n  if (!isPlainObject(input) || Object.keys(input).some(key => !requestFields.has(key)) ||\n    Boolean(input.module) == Boolean(input.program)) {\n    invalidInput(\"Android application generation requires a closed request with exactly one semantic module or program.\")\n  }\n  if (input.language !== undefined && input.language != \"android\" || input.role !== undefined && input.role != \"application\") {\n    invalidInput(\"Android application generation accepts only the Android application role.\")\n  }\n  const configuration = normalizeConfiguration(input.configuration)\n  const program = input.program ?? normalizeSingleModule(\n    /** @type {import(\"../semantic/types.js\").SemanticModule | undefined} */ (input.module))\n  const prepared = preflightSemanticProgram({\n    backendLanguage: \"kotlin\",\n    diagnosticLanguage: \"android\",\n    program: /** @type {import(\"../semantic/types.js\").SemanticProgram} */ (program),\n    sourceLanguages: androidSourceLanguages\n  })\n  validateActivityClassName(configuration.activityClassName, prepared.program.entryModule)\n  const packagePath = configuration.packageName.replaceAll(\".\", \"/\")\n  const semanticRoot = `${projectRoot}/app/src/main/kotlin/${packagePath}/semantic`\n  const modulePaths = new Map(prepared.modules.map(module => [\n    /** @type {string} */ (Reflect.get(module, \"id\")),\n    `${semanticRoot}/${moduleName(/** @type {string} */ (Reflect.get(module, \"id\")))}.kt`\n  ]))\n  const resources = normalizeInputFiles(input.resources, \"resource\")\n  const assets = normalizeInputFiles(input.assets, \"asset\")\n  const fixedPaths = applicationPaths(configuration, modulePaths)\n  const completePaths = [\n    ...fixedPaths,\n    ...resources.map(({fullPath}) => fullPath),\n    ...assets.map(({fullPath}) => fullPath)\n  ]\n  const conflict = findPortableArtifactPathConflict(completePaths)\n\n  if (conflict) {\n    invalidPath(`Application artifact path '${conflict.path}' has a ${conflict.kind} conflict${conflict.other ? ` with '${conflict.other}'` : \"\"}.`)\n  }\n\n  return {...prepared, assets, configuration, modulePaths, packagePath, resources}\n}\n\n/**\n * Generates one complete deterministic Android/Kotlin project.\n * @param {Record<string, unknown>} input - Application generation request.\n * @returns {{artifacts: import(\"../semantic/types.js\").GeneratedSetArtifact[], metadata: {applicationManifest: string, platformQualification: string}, target: \"android\"}} Candidate artifact set.\n */\nexport function generateAndroidApplication(input) {\n  const prepared = preflightAndroidApplication(input)\n  const configurationSpans = /** @type {ConfigurationSpan[]} */ ([])\n  const configuration = prepared.configuration\n  const packagePath = prepared.packagePath\n  const semanticArtifacts = renderSemanticArtifacts(prepared)\n  const artifacts = /** @type {import(\"../semantic/types.js\").GeneratedSetArtifact[]} */ ([\n    configuredText(`${projectRoot}/app/build.gradle.kts`, \"manifest\", renderAppBuild(configuration, configurationSpans),\n      \"Pinned dependency-minimal Android application build.\"),\n    configuredText(`${projectRoot}/app/src/androidTest/AndroidManifest.xml`, \"manifest\",\n      renderAndroidTestManifest(configuration, configurationSpans), \"Platform-only Android instrumentation declaration.\"),\n    configuredText(`${projectRoot}/app/src/androidTest/kotlin/${packagePath}/SemantifoldUiInstrumentation.kt`, \"support\",\n      renderInstrumentation(configuration, configurationSpans), \"Platform-only accessibility and lifecycle assertion.\"),\n    configuredText(`${projectRoot}/app/src/main/AndroidManifest.xml`, \"manifest\",\n      renderAndroidManifest(configuration, configurationSpans), \"Closed allowlisted Android application manifest.\"),\n    configuredText(`${projectRoot}/app/src/main/kotlin/${packagePath}/${configuration.activityClassName}.kt`, \"entry\",\n      renderActivity(configuration, prepared.program.entryModule, configurationSpans),\n      \"Synthetic Android activity lifecycle and native output view binding.\"),\n    ...semanticArtifacts,\n    syntheticText(`${projectRoot}/app/src/main/res/layout/activity_main.xml`, \"resource\", renderLayout(),\n      \"Synthetic one-view Android layout and accessibility identity.\"),\n    configuredText(`${projectRoot}/app/src/main/res/values/strings.xml`, \"resource\",\n      renderStrings(configuration, configurationSpans), \"Escaped application labels derived from configuration.\"),\n    syntheticText(`${projectRoot}/app/src/main/res/values/themes.xml`, \"resource\", renderTheme(),\n      \"Closed platform-native application theme.\"),\n    syntheticText(`${projectRoot}/app/src/main/res/xml/backup_rules.xml`, \"resource\", renderBackupRules(),\n      \"Closed API 23-30 full-backup exclusions.\"),\n    syntheticText(`${projectRoot}/app/src/main/res/xml/data_extraction_rules.xml`, \"resource\", renderDataExtractionRules(),\n      \"Closed Android 12+ cloud-backup and device-transfer exclusions.\"),\n    configuredText(`${projectRoot}/app/src/test/kotlin/${packagePath}/SemantifoldEntryTest.kt`, \"support\",\n      renderUnitTest(configuration, prepared.program.entryModule, configurationSpans),\n      \"JUnit test-scope-only semantic determinism assertion.\"),\n    syntheticText(`${projectRoot}/build.gradle.kts`, \"manifest\", renderRootBuild(),\n      \"Pinned Android and Kotlin build plugins.\"),\n    syntheticText(`${projectRoot}/gradle.properties`, \"support\", renderGradleProperties(),\n      \"Pinned hermetic Gradle process properties.\"),\n    configuredText(`${projectRoot}/settings.gradle.kts`, \"manifest\", renderSettings(configuration, configurationSpans),\n      \"Closed official Gradle plugin and dependency repositories.\"),\n    ...prepared.resources.map(inputFileArtifact),\n    ...prepared.assets.map(inputFileArtifact)\n  ])\n\n  artifacts.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0)\n  const manifestPath = `${projectRoot}/semantifold-project.json`\n\n  artifacts.push(syntheticText(manifestPath, \"manifest\",\n    renderProjectManifest(prepared, artifacts, manifestPath, configurationSpans),\n    \"Versioned Android project ownership, toolchain, and provenance manifest.\"))\n\n  return {\n    artifacts,\n    metadata: {applicationManifest: manifestPath, platformQualification: \"tensorbuzz-kvm\"},\n    target: \"android\"\n  }\n}\n\n/**\n * Renders the mapped semantic Kotlin artifacts for every program module.\n * @param {ReturnType<typeof preflightAndroidApplication>} prepared - Prepared application.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact[]} Semantic Kotlin artifacts.\n */\nfunction renderSemanticArtifacts(prepared) {\n  const semanticRoot = `${projectRoot}/app/src/main/kotlin/${prepared.packagePath}/semantic`\n  /** @type {import(\"../semantic/types.js\").GeneratedSetArtifact[]} */\n  const artifacts = [syntheticText(`${semanticRoot}/SemantifoldRuntime.kt`, \"support\",\n    androidKotlinRuntime.replaceAll(\"__PACKAGE__\", prepared.configuration.packageName),\n    \"Shared Android application output capture and checked Kotlin scalar support.\")]\n  const declarations = new Map()\n\n  for (const module of prepared.modules) {\n    for (const declaration of module.functions) declarations.set(declaration.id, {\n      declaration,\n      moduleId: /** @type {string} */ (Reflect.get(module, \"id\"))\n    })\n  }\n  for (const module of prepared.modules) {\n    const moduleId = /** @type {string} */ (Reflect.get(module, \"id\"))\n    const filename = /** @type {string} */ (prepared.modulePaths.get(moduleId))\n    const sinkName = outputSinkName(module)\n    const writer = new SourceWriter({\n      callArgumentSuffix: sinkName,\n      callNameResolver: expression => {\n        const resolved = declarations.get(expression.resolution?.declarationId)\n\n        if (!resolved) throw new TypeError(`Unknown validated Android function '${expression.resolution?.declarationId}'.`)\n\n        return `SemantifoldModule${moduleName(resolved.moduleId)}.${resolved.declaration.name}`\n      },\n      filename,\n      language: \"kotlin\",\n      methodStringEquality: true,\n      module,\n      program: prepared.program,\n      programPaths: prepared.modulePaths,\n      sources: prepared.sources\n    })\n\n    writer.synthetic(`@file:Suppress(\"PLATFORM_CLASS_MAPPED_TO_KOTLIN\")\\n\\npackage ${prepared.configuration.packageName}.semantic\\n\\n`,\n      \"Android semantic package namespace\", [module], [\"\"])\n    emitSemanticModule(writer, module, moduleId, moduleId == prepared.program.entryModule, sinkName)\n    const mapping = finalizeMapping(writer.finish())\n\n    artifacts.push({\n      content: mapping.generated.content,\n      contentKind: \"text\",\n      mediaType: \"text/x-kotlin\",\n      ownership: \"generated\",\n      path: filename,\n      provenance: {kind: \"text\", mapping, sourceMap: toSourceMapV3(mapping), sourceMapFilename: `${filename}.map`},\n      role: \"source\"\n    })\n  }\n\n  return artifacts\n}\n\n/**\n * Emits one namespaced semantic module and its entry bridge when applicable.\n * @param {SourceWriter} writer - Mapped Kotlin writer.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Prepared module.\n * @param {string} moduleId - Stable module identity.\n * @param {boolean} entry - Whether this module owns the entry block.\n * @param {string} sinkName - Collision-safe output sink binding.\n */\nfunction emitSemanticModule(writer, module, moduleId, entry, sinkName) {\n  writer.synthetic(`internal object SemantifoldModule${moduleName(moduleId)} {\\n`,\n    \"Android semantic module namespace\", [module], [\"\"])\n  module.functions.forEach((declaration, functionIndex) => {\n    const path = `/functions/${functionIndex}`\n\n    writer.synthetic(\"  \", \"Android namespaced function indentation\", [declaration], [path])\n    writer.mapped(\"fun\", {mappingKind: \"anchor\", node: declaration, path})\n    writer.synthetic(\" \", \"declaration spacing\", [declaration], [path])\n    writer.mapped(declaration.name, {mappingKind: \"exact\", node: declaration, path, role: \"name\"})\n    writer.synthetic(\"(\", \"function parameter scaffold\", [declaration], [path])\n    declaration.parameters.forEach((parameter, parameterIndex) => {\n      const parameterPath = `${path}/parameters/${parameterIndex}`\n\n      if (parameterIndex) writer.synthetic(\", \", \"parameter separator\", [parameter], [parameterPath])\n      writer.mapped(parameter.name, {mappingKind: \"exact\", node: parameter, path: parameterPath, role: \"name\"})\n      writer.synthetic(\": \", \"parameter annotation scaffold\", [parameter], [parameterPath])\n      writer.mapped(emitScalarType(\"kotlin\", parameter.type), {mappingKind: \"exact\", node: parameter.type,\n        path: `${parameterPath}/type`, role: \"type\"})\n    })\n    if (declaration.parameters.length) writer.synthetic(\", \", \"output sink parameter separator\", [declaration], [path])\n    writer.synthetic(`${sinkName}: SemantifoldOutputSink): `, \"shared Android output sink parameter\", [declaration], [path])\n    writer.mapped(emitScalarType(\"kotlin\", declaration.returnType), {mappingKind: \"exact\", node: declaration.returnType,\n      path: `${path}/returnType`, role: \"type\"})\n    writer.synthetic(\" {\\n\", \"Kotlin function body scaffold\", [declaration], [path])\n    emitKotlinBlock(writer, declaration.body, \"    \", `${path}/body`, `${sinkName}.write`)\n    writer.synthetic(\"  }\\n\", \"Kotlin function body scaffold\", [declaration], [path])\n  })\n  if (entry) {\n    writer.synthetic(\"  fun semantifoldEntry(): java.util.ArrayList<String> {\\n\", \"Android semantic entry scaffold\", [module.entryPoint], [\"/entryPoint\"])\n    writer.synthetic(`    val ${sinkName} = SemantifoldOutputSink()\\n`, \"Android output sink allocation\",\n      [module.entryPoint], [\"/entryPoint\"])\n    writer.synthetic(`    ${sinkName}.reset()\\n`, \"Android lifecycle-safe output reset\", [module.entryPoint], [\"/entryPoint\"])\n    emitKotlinBlock(writer, module.entryPoint.body, \"    \", \"/entryPoint/body\", `${sinkName}.write`)\n    writer.synthetic(`    return ${sinkName}.snapshot()\\n`, \"Android semantic output return\",\n      [module.entryPoint], [\"/entryPoint\"])\n    writer.synthetic(\"  }\\n\", \"Android semantic entry scaffold\", [module.entryPoint], [\"/entryPoint\"])\n  }\n  writer.synthetic(\"}\\n\", \"Android semantic module namespace\", [module], [\"\"])\n}\n\n/**\n * Lists every fixed generated path before any writer is allocated.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized application configuration.\n * @param {Map<string, string>} modulePaths - Semantic module output paths.\n * @returns {string[]} Fixed owned artifact paths.\n */\nfunction applicationPaths(configuration, modulePaths) {\n  const packagePath = configuration.packageName.replaceAll(\".\", \"/\")\n\n  return [\n    `${projectRoot}/app/build.gradle.kts`,\n    `${projectRoot}/app/src/androidTest/AndroidManifest.xml`,\n    `${projectRoot}/app/src/androidTest/kotlin/${packagePath}/SemantifoldUiInstrumentation.kt`,\n    `${projectRoot}/app/src/main/AndroidManifest.xml`,\n    `${projectRoot}/app/src/main/kotlin/${packagePath}/${configuration.activityClassName}.kt`,\n    ...modulePaths.values(),\n    `${projectRoot}/app/src/main/kotlin/${packagePath}/semantic/SemantifoldRuntime.kt`,\n    `${projectRoot}/app/src/main/res/layout/activity_main.xml`,\n    `${projectRoot}/app/src/main/res/values/strings.xml`,\n    `${projectRoot}/app/src/main/res/values/themes.xml`,\n    `${projectRoot}/app/src/main/res/xml/backup_rules.xml`,\n    `${projectRoot}/app/src/main/res/xml/data_extraction_rules.xml`,\n    `${projectRoot}/app/src/test/kotlin/${packagePath}/SemantifoldEntryTest.kt`,\n    `${projectRoot}/build.gradle.kts`,\n    `${projectRoot}/gradle.properties`,\n    `${projectRoot}/settings.gradle.kts`,\n    `${projectRoot}/semantifold-project.json`\n  ]\n}\n\n/**\n * Renders the pinned root plugin declarations.\n * @returns {string} Root Gradle Kotlin script.\n */\nfunction renderRootBuild() {\n  return `plugins {\n  id(\"com.android.application\") version \"${toolchain.androidGradlePlugin}\" apply false\n  id(\"org.jetbrains.kotlin.android\") version \"${toolchain.kotlin}\" apply false\n}\n`\n}\n\n/**\n * Renders closed project settings and repositories.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.\n * @returns {string} Settings Gradle Kotlin script.\n */\nfunction renderSettings(configuration, spans) {\n  return configured(`${projectRoot}/settings.gradle.kts`, spans, [`pluginManagement {\n  repositories {\n    google()\n    mavenCentral()\n    gradlePluginPortal()\n  }\n}\n\ndependencyResolutionManagement {\n  repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)\n  repositories {\n    google()\n    mavenCentral()\n  }\n}\n\nrootProject.name = \"`, field(\"productName\", kotlinEscape(configuration.productName)), `\"\ninclude(\":app\")\n`])\n}\n\n/**\n * Renders deterministic Gradle process properties.\n * @returns {string} Gradle properties file.\n */\nfunction renderGradleProperties() {\n  return `org.gradle.caching=false\norg.gradle.configuration-cache=false\norg.gradle.daemon=false\norg.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 -Duser.language=en -Duser.country=US -Duser.timezone=UTC\norg.gradle.parallel=false\nkotlin.stdlib.default.dependency=false\nkotlin.code.style=official\n`\n}\n\n/**\n * Renders the application module build contract.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.\n * @returns {string} Application Gradle Kotlin script.\n */\nfunction renderAppBuild(configuration, spans) {\n  return configured(`${projectRoot}/app/build.gradle.kts`, spans, [\n    `import org.jetbrains.kotlin.gradle.dsl.JvmTarget\nimport org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile\n\nplugins {\n  id(\"com.android.application\")\n  id(\"org.jetbrains.kotlin.android\")\n}\n\ndependencies {\n  testRuntimeOnly(\"org.hamcrest:hamcrest-core:1.3\") {\n    isTransitive = false\n  }\n}\n\nval semantifoldKotlinHome = providers.environmentVariable(\"SEMANTIFOLD_KOTLIN_HOME\").orNull\n  ?: throw GradleException(\"SEMANTIFOLD_ANDROID_INFRASTRUCTURE: SEMANTIFOLD_KOTLIN_HOME is required\")\nval semantifoldKotlinStdlib = file(\"$semantifoldKotlinHome/lib/kotlin-stdlib.jar\")\nif (!semantifoldKotlinStdlib.isFile) {\n  throw GradleException(\"SEMANTIFOLD_ANDROID_INFRASTRUCTURE: pinned Kotlin compile library is missing\")\n}\nval semantifoldAcceptanceRoot = providers.environmentVariable(\"SEMANTIFOLD_ANDROID_ACCEPTANCE_ROOT\").orNull\n  ?: throw GradleException(\"SEMANTIFOLD_ANDROID_INFRASTRUCTURE: SEMANTIFOLD_ANDROID_ACCEPTANCE_ROOT is required\")\nval semantifoldDebugKeystore = file(\"$semantifoldAcceptanceRoot/debug.keystore\")\nif (!semantifoldDebugKeystore.isFile) {\n  throw GradleException(\"SEMANTIFOLD_ANDROID_INFRASTRUCTURE: ephemeral debug keystore is missing\")\n}\n\nandroid {\n  namespace = \"`,\n    field(\"namespace\", configuration.namespace), `\"\\n  compileSdk = `, field(\"compileSdk\", String(configuration.compileSdk)),\n    `\\n  buildToolsVersion = \"`, field(\"buildToolsVersion\", configuration.buildToolsVersion), `\"\\n\\n  defaultConfig {\\n    applicationId = \"`,\n    field(\"applicationId\", configuration.applicationId), `\"\\n    minSdk = `, field(\"minimumSdk\", String(configuration.minimumSdk)),\n    `\\n    targetSdk = `, field(\"targetSdk\", String(configuration.targetSdk)), `\\n    versionCode = `,\n    field(\"versionCode\", String(configuration.versionCode)), `\\n    versionName = \"`, field(\"versionName\", kotlinEscape(configuration.versionName)),\n    `\"\\n    testApplicationId = \"`, field(\"applicationId\", configuration.applicationId),\n    `.test\"\\n    testInstrumentationRunner = \"`, field(\"packageName\", configuration.packageName),\n    `.SemantifoldUiInstrumentation\"\\n  }\\n\\n  signingConfigs {\\n    getByName(\"debug\") {\\n      storeFile = semantifoldDebugKeystore\\n      storePassword = \"android\"\\n      keyAlias = \"androiddebugkey\"\\n      keyPassword = \"android\"\\n    }\\n  }\\n  buildTypes {\\n    getByName(\"debug\") {\\n      signingConfig = signingConfigs.getByName(\"debug\")\\n    }\\n  }\\n  buildFeatures {\\n    buildConfig = false\\n  }\\n  compileOptions {\\n    sourceCompatibility = JavaVersion.VERSION_21\\n    targetCompatibility = JavaVersion.VERSION_21\\n  }\\n  lint {\\n    abortOnError = true\\n    checkDependencies = true\\n    disable += \"MissingApplicationIcon\"\\n    disable += \"OldTargetApi\"\\n    disable += \"GradleDependency\"\\n    warningsAsErrors = true\\n  }\\n  packaging {\\n    resources.excludes += setOf(\"META-INF/LICENSE*\", \"META-INF/NOTICE*\")\\n  }\\n}\\n\\ntasks.withType<KotlinJvmCompile>().configureEach {\\n  libraries.from(files(semantifoldKotlinStdlib))\\n  compilerOptions {\\n    allWarningsAsErrors.set(true)\\n    freeCompilerArgs.addAll(\"-Xno-call-assertions\", \"-Xno-param-assertions\", \"-Xno-receiver-assertions\")\\n    jvmTarget.set(JvmTarget.JVM_21)\\n  }\\n}\\n\\ndependencies {\\n  testImplementation(\"junit:junit:4.13.2\") {\\n    isTransitive = false\\n  }\\n}\\n`\n  ])\n}\n\n/**\n * Renders the allowlisted Android application manifest.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.\n * @returns {string} Android application manifest.\n */\nfunction renderAndroidManifest(configuration, spans) {\n  const orientation = configuration.orientation == \"unspecified\" ? \"\" : ` android:screenOrientation=\"${configuration.orientation}\"`\n\n  return configured(`${projectRoot}/app/src/main/AndroidManifest.xml`, spans, [\n    `<?xml version=\"1.0\" encoding=\"utf-8\"?>\\n<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\">\\n  <application\\n    android:allowBackup=\"false\"\\n    android:dataExtractionRules=\"@xml/data_extraction_rules\"\\n    android:fullBackupContent=\"@xml/backup_rules\"\\n    android:label=\"@string/app_name\"\\n    android:supportsRtl=\"true\"\\n    android:theme=\"@style/Theme.Semantifold\">\\n    <activity\\n      android:name=\"`,\n    field(\"packageName\", configuration.packageName), `.`, field(\"activityClassName\", configuration.activityClassName),\n    `\"\\n      android:exported=\"true\"`,\n    orientation ? field(\"orientation\", orientation) : \"\", `>\\n      <intent-filter>\\n        <action android:name=\"android.intent.action.MAIN\" />\\n        <category android:name=\"android.intent.category.LAUNCHER\" />\\n      </intent-filter>\\n    </activity>\\n  </application>\\n</manifest>\\n`\n  ])\n}\n\n/**\n * Renders explicit API 23-30 exclusions for every full-backup storage domain.\n * @returns {string} Android full-backup rules XML.\n */\nfunction renderBackupRules() {\n  return `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<full-backup-content>\n  <exclude domain=\"root\" path=\".\" />\n  <exclude domain=\"file\" path=\".\" />\n  <exclude domain=\"database\" path=\".\" />\n  <exclude domain=\"sharedpref\" path=\".\" />\n  <exclude domain=\"external\" path=\".\" />\n  <exclude domain=\"device_root\" path=\".\" />\n  <exclude domain=\"device_file\" path=\".\" />\n  <exclude domain=\"device_database\" path=\".\" />\n  <exclude domain=\"device_sharedpref\" path=\".\" />\n</full-backup-content>\n`\n}\n\n/**\n * Renders explicit Android 12+ exclusions for every cloud-backup and device-transfer storage domain.\n * @returns {string} Android data extraction rules XML.\n */\nfunction renderDataExtractionRules() {\n  return `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<data-extraction-rules>\n  <cloud-backup>\n    <exclude domain=\"root\" path=\".\" />\n    <exclude domain=\"file\" path=\".\" />\n    <exclude domain=\"database\" path=\".\" />\n    <exclude domain=\"sharedpref\" path=\".\" />\n    <exclude domain=\"external\" path=\".\" />\n    <exclude domain=\"device_root\" path=\".\" />\n    <exclude domain=\"device_file\" path=\".\" />\n    <exclude domain=\"device_database\" path=\".\" />\n    <exclude domain=\"device_sharedpref\" path=\".\" />\n  </cloud-backup>\n  <device-transfer>\n    <exclude domain=\"root\" path=\".\" />\n    <exclude domain=\"file\" path=\".\" />\n    <exclude domain=\"database\" path=\".\" />\n    <exclude domain=\"sharedpref\" path=\".\" />\n    <exclude domain=\"external\" path=\".\" />\n    <exclude domain=\"device_root\" path=\".\" />\n    <exclude domain=\"device_file\" path=\".\" />\n    <exclude domain=\"device_database\" path=\".\" />\n    <exclude domain=\"device_sharedpref\" path=\".\" />\n  </device-transfer>\n</data-extraction-rules>\n`\n}\n\n/**\n * Renders the platform-only instrumentation manifest.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.\n * @returns {string} Android test manifest.\n */\nfunction renderAndroidTestManifest(configuration, spans) {\n  return configured(`${projectRoot}/app/src/androidTest/AndroidManifest.xml`, spans, [\n    `<?xml version=\"1.0\" encoding=\"utf-8\"?>\\n<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\">\\n  <instrumentation\\n    android:name=\"`,\n    field(\"packageName\", configuration.packageName), `.SemantifoldUiInstrumentation\"\\n    android:targetPackage=\"`,\n    field(\"applicationId\", xmlEscape(configuration.applicationId)), `\" />\\n</manifest>\\n`\n  ])\n}\n\n/**\n * Renders the synthetic launcher activity.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized configuration.\n * @param {string} entryModule - Selected semantic entry module identity.\n * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.\n * @returns {string} Kotlin launcher activity source.\n */\nfunction renderActivity(configuration, entryModule, spans) {\n  const resourceImport = configuration.namespace == configuration.packageName\n    ? []\n    : [\"import \", field(\"namespace\", configuration.namespace), \".R\\n\"]\n\n  return configured(`${projectRoot}/app/src/main/kotlin/${configuration.packageName.replaceAll(\".\", \"/\")}/${configuration.activityClassName}.kt`, spans, [\n    \"package \", field(\"packageName\", configuration.packageName), `\n\nimport android.app.Activity\nimport android.annotation.SuppressLint\nimport android.os.Bundle\nimport android.widget.TextView\n`, ...resourceImport, `import `, field(\"packageName\", configuration.packageName),\n    `.semantic.SemantifoldModule${moduleName(entryModule)}\n\nclass `, field(\"activityClassName\", configuration.activityClassName), ` : Activity() {\n  @SuppressLint(\"SetTextI18n\")\n  override fun onCreate(savedInstanceState: Bundle?) {\n    super.onCreate(savedInstanceState)\n    setContentView(R.layout.activity_main)\n    val lines = SemantifoldModule${moduleName(entryModule)}.semantifoldEntry()\n    val output = java.lang.StringBuilder()\n    var index = 0\n    while (index < lines.size) {\n      if (index > 0) output.append('\\\\n')\n      output.append(lines[index])\n      index += 1\n    }\n    findViewById<TextView>(R.id.semantifold_output).text = output.toString()\n  }\n}\n`\n  ])\n}\n\n/**\n * Renders the single accessibility-important native text view.\n * @returns {string} Android layout XML.\n */\nfunction renderLayout() {\n  return `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<TextView xmlns:android=\"http://schemas.android.com/apk/res/android\"\n  android:id=\"@+id/semantifold_output\"\n  android:layout_width=\"match_parent\"\n  android:layout_height=\"match_parent\"\n  android:gravity=\"center\"\n  android:importantForAccessibility=\"yes\"\n  android:textIsSelectable=\"true\" />\n`\n}\n\n/**\n * Renders configuration-derived string resources.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.\n * @returns {string} Android string resource XML.\n */\nfunction renderStrings(configuration, spans) {\n  return configured(`${projectRoot}/app/src/main/res/values/strings.xml`, spans, [\n    `<?xml version=\"1.0\" encoding=\"utf-8\"?>\\n<resources>\\n  <string name=\"app_name\">`,\n    field(\"displayName\", xmlEscape(configuration.displayName)), `</string>\\n</resources>\\n`\n  ])\n}\n\n/**\n * Renders the fixed platform-native baseline theme.\n * @returns {string} Android theme resource XML.\n */\nfunction renderTheme() {\n  return `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<resources>\n  <style name=\"Theme.Semantifold\" parent=\"android:style/Theme.Material.Light.NoActionBar\">\n    <item name=\"android:fontFamily\">sans</item>\n    <item name=\"android:windowActionModeOverlay\">true</item>\n  </style>\n</resources>\n`\n}\n\n/**\n * Renders the sole JUnit test-scope semantic assertion.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized configuration.\n * @param {string} entryModule - Selected semantic entry module identity.\n * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.\n * @returns {string} Kotlin unit test source.\n */\nfunction renderUnitTest(configuration, entryModule, spans) {\n  return configured(`${projectRoot}/app/src/test/kotlin/${configuration.packageName.replaceAll(\".\", \"/\")}/SemantifoldEntryTest.kt`, spans, [\n    \"package \", field(\"packageName\", configuration.packageName), `\n\nimport `, field(\"packageName\", configuration.packageName), `.semantic.SemantifoldModule${moduleName(entryModule)}\nimport org.junit.Test\n\nclass SemantifoldEntryTest {\n  @Test\n  fun entryIsDeterministicAcrossFreshRuns() {\n    val firstOutput = SemantifoldModule${moduleName(entryModule)}.semantifoldEntry()\n    val secondOutput = SemantifoldModule${moduleName(entryModule)}.semantifoldEntry()\n    if (!firstOutput.equals(secondOutput)) {\n      throw AssertionError(\"Semantic entry output differs across fresh runs.\")\n    }\n  }\n}\n`\n  ])\n}\n\n/**\n * Renders the framework-only instrumentation runner.\n * @param {import(\"../semantic/types.js\").AndroidApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Collected configuration provenance spans.\n * @returns {string} Kotlin instrumentation source.\n */\nfunction renderInstrumentation(configuration, spans) {\n  const resourceImport = configuration.namespace == configuration.packageName\n    ? []\n    : [\"import \", field(\"namespace\", configuration.namespace), \".R\\n\"]\n\n  return configured(`${projectRoot}/app/src/androidTest/kotlin/${configuration.packageName.replaceAll(\".\", \"/\")}/SemantifoldUiInstrumentation.kt`, spans, [\n    \"package \", field(\"packageName\", configuration.packageName), `\n\nimport android.app.Activity\nimport android.app.Instrumentation\nimport android.content.Intent\nimport android.os.Bundle\nimport android.util.Base64\nimport android.view.View\nimport android.widget.TextView\nimport java.nio.charset.StandardCharsets\n`, ...resourceImport, `\nclass SemantifoldUiInstrumentation : Instrumentation() {\n  private var inputArguments: Bundle? = null\n\n  override fun onCreate(arguments: Bundle?) {\n    inputArguments = arguments\n    start()\n  }\n\n  override fun onStart() {\n    try {\n      val providedArguments = inputArguments\n        ?: throw IllegalStateException(\"missing instrumentation arguments\")\n      val encoded = providedArguments.getString(\"expected_output_base64\")\n        ?: throw IllegalStateException(\"missing expected_output_base64 instrumentation argument\")\n      val expected = String(Base64.decode(encoded, Base64.NO_WRAP), StandardCharsets.UTF_8)\n      val launch = targetContext.packageManager.getLaunchIntentForPackage(targetContext.packageName)\n        ?: throw IllegalStateException(\"generated application has no launcher intent\")\n      launch.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)\n      val activity = startActivitySync(launch) as `, field(\"activityClassName\", configuration.activityClassName), `\n      assertOutput(activity, expected)\n      val monitor = addMonitor(`, field(\"activityClassName\", configuration.activityClassName), `::class.java.name, null, false)\n      runOnMainSync { activity.recreate() }\n      waitForIdleSync()\n      val recreated = waitForMonitorWithTimeout(monitor, 10_000)\n        ?: throw IllegalStateException(\"activity was not recreated\")\n      assertOutput(recreated, expected)\n      finish(Activity.RESULT_OK, Bundle())\n    } catch (error: Throwable) {\n      val result = Bundle()\n      result.putString(\"semantifold_failure\", android.util.Log.getStackTraceString(error))\n      finish(Activity.RESULT_CANCELED, result)\n    }\n  }\n\n  private fun assertOutput(activity: Activity, expected: String) {\n    waitForIdleSync()\n    val actual = activity.findViewById<TextView>(R.id.semantifold_output)\n      ?: throw IllegalStateException(\"missing semantifold_output view\")\n    if (actual.visibility != View.VISIBLE) throw IllegalStateException(\"output view is not visible\")\n    if (actual.javaClass != TextView::class.java) throw IllegalStateException(\"output view is not a native TextView\")\n    if (!actual.text.toString().equals(expected)) throw IllegalStateException(\"output text mismatch\")\n    if (actual.contentDescription != null) throw IllegalStateException(\"output content description must stay absent\")\n    if (actual.importantForAccessibility != View.IMPORTANT_FOR_ACCESSIBILITY_YES) {\n      throw IllegalStateException(\"output view is not accessibility-important\")\n    }\n  }\n}\n`\n  ])\n}\n\n/**\n * Renders the ownership, toolchain, and provenance manifest.\n * @param {ReturnType<typeof preflightAndroidApplication>} prepared - Prepared application.\n * @param {import(\"../semantic/types.js\").GeneratedSetArtifact[]} artifacts - Owned project artifacts.\n * @param {string} manifestPath - Ownership manifest path.\n * @param {ConfigurationSpan[]} spans - Configuration provenance spans.\n * @returns {string} Canonical project manifest JSON.\n */\nfunction renderProjectManifest(prepared, artifacts, manifestPath, spans) {\n  const inputPaths = new Set([...prepared.resources, ...prepared.assets].map(({fullPath}) => fullPath))\n  const semanticArtifacts = artifacts.filter(artifact => artifact.provenance.kind == \"text\")\n  const ownedPaths = [...artifacts.map(({path}) => path), manifestPath]\n\n  return stringifyCanonicalJson({\n    configuration: prepared.configuration,\n    generator: {name: \"semantifold\", version: generatorVersion},\n    ownership: {\n      excludedPathPatterns,\n      ownedPaths,\n      ownedRoot: projectRoot,\n      sha256: artifacts.map(artifact => ({path: artifact.path, sha256: hashContent(artifact.content)}))\n    },\n    provenance: {\n      configuration: Object.keys(prepared.configuration).sort().map(fieldName => ({\n        field: fieldName,\n        manifestPointer: `/configuration/${fieldName}`,\n        outputs: configurationOutputs(spans, fieldName)\n      })),\n      inputs: [...prepared.resources, ...prepared.assets].map(item => ({\n        contentKind: item.contentKind,\n        mediaType: item.mediaType,\n        path: item.fullPath,\n        sha256: item.sha256\n      })),\n      semanticSources: prepared.sources.map(source => ({\n        artifacts: semanticArtifacts.filter(artifact => artifact.provenance.kind == \"text\" &&\n          artifact.provenance.mapping.spans.some(({origin}) => originReferencesFilename(origin, source.filename)))\n          .map(({path}) => path),\n        filename: source.filename,\n        ...(source.language === undefined ? {} : {language: source.language}),\n        sha256: createHash(\"sha256\").update(source.content).digest(\"hex\")\n      })),\n      syntheticScaffolding: [...artifacts.filter(artifact => artifact.provenance.kind == \"synthetic\" &&\n        !inputPaths.has(artifact.path)).map(({path}) => path), manifestPath]\n    },\n    schema: \"SemantifoldAndroidProject\",\n    semanticProgram: semanticProgramManifest(prepared),\n    target: \"android\",\n    toolchain,\n    version: 1\n  })\n}\n\n/**\n * Renders semantic module and source identities for the project manifest.\n * @param {ReturnType<typeof preflightAndroidApplication>} prepared - Prepared application.\n * @returns {Record<string, unknown>} Semantic program manifest.\n */\nfunction semanticProgramManifest(prepared) {\n  const sourceContent = new Map(prepared.sources.map(source => [source.filename, source.content]))\n  const order = new Map(prepared.program.modules.map((module, index) => [module.id, index]))\n  const modules = prepared.program.modules.map(module => {\n    const source = prepared.program.sources.find(candidate => candidate.filename == module.sourceFilename)\n    const content = sourceContent.get(module.sourceFilename)\n\n    if (!source || content === undefined) throw new TypeError(`Preflighted Android module '${module.id}' lost source ownership.`)\n\n    return {\n      dependencies: [...new Set(module.imports.map(({moduleId}) => moduleId))]\n        .sort((left, right) => /** @type {number} */ (order.get(left)) - /** @type {number} */ (order.get(right))),\n      generatedArtifacts: [prepared.modulePaths.get(module.id)],\n      id: module.id,\n      namespace: `SemantifoldModule${moduleName(module.id)}`,\n      source: {filename: source.filename, id: source.id, sha256: createHash(\"sha256\").update(content).digest(\"hex\")}\n    }\n  })\n  const entryId = prepared.program.entryModule\n\n  return {\n    entry: {\n      activityArtifact: `${projectRoot}/app/src/main/kotlin/${prepared.packagePath}/${prepared.configuration.activityClassName}.kt`,\n      generatedArtifact: prepared.modulePaths.get(entryId),\n      generatedFunctionIdentity: `SemantifoldModule${moduleName(entryId)}.semantifoldEntry`,\n      moduleId: entryId\n    },\n    modules,\n    schema: \"SemantifoldAndroidSemanticProgram\",\n    sources: prepared.program.sources.map(source => ({\n      filename: source.filename,\n      id: source.id,\n      language: source.language,\n      moduleIds: modules.filter(module => module.source.filename == source.filename).map(({id}) => id),\n      ownership: source.ownership ?? \"application\",\n      sha256: createHash(\"sha256\").update(/** @type {string} */ (sourceContent.get(source.filename))).digest(\"hex\")\n    })),\n    version: 1\n  }\n}\n\n/**\n * Validates and normalizes the closed Android configuration.\n * @param {unknown} candidate - Candidate configuration.\n * @returns {import(\"../semantic/types.js\").AndroidApplicationConfiguration} Normalized configuration.\n */\nfunction normalizeConfiguration(candidate) {\n  if (candidate === undefined) candidate = {}\n  if (!isPlainObject(candidate) || Object.keys(candidate).some(key => !configurationFields.has(key))) {\n    invalidConfiguration(\"Android application configuration must be a closed plain object.\")\n  }\n  const configuration = /** @type {import(\"../semantic/types.js\").AndroidApplicationConfigurationInput} */ (candidate)\n  const applicationId = configuration.applicationId ?? \"dev.semantifold.generated\"\n  const namespace = configuration.namespace ?? applicationId\n  const packageName = configuration.packageName ?? namespace\n  const activityClassName = configuration.activityClassName ?? \"MainActivity\"\n  const productName = configuration.productName ?? \"Semantifold\"\n  const displayName = configuration.displayName ?? \"Semantifold\"\n  const minimumSdk = configuration.minimumSdk ?? 23\n  const targetSdk = configuration.targetSdk ?? toolchain.targetSdk\n  const compileSdk = configuration.compileSdk ?? toolchain.compileSdk\n  const buildToolsVersion = configuration.buildToolsVersion ?? toolchain.buildTools\n  const versionCode = configuration.versionCode ?? 1\n  const versionName = configuration.versionName ?? \"1.0.0\"\n  const orientation = configuration.orientation ?? \"unspecified\"\n  const theme = configuration.theme ?? \"system\"\n\n  for (const [label, value] of [[\"Application ID\", applicationId], [\"Namespace\", namespace], [\"Package name\", packageName]]) {\n    if (typeof value != \"string\" || !isPackageName(value)) invalidConfiguration(`${label} must be a lowercase Java package identity.`)\n  }\n  if (typeof activityClassName != \"string\" || !/^[A-Z][A-Za-z0-9]*$/u.test(activityClassName) || kotlinKeywords.has(activityClassName)) {\n    invalidConfiguration(\"Activity class name must be an ASCII upper-camel Kotlin identifier.\")\n  }\n  for (const [label, value] of [[\"Product name\", productName], [\"Display name\", displayName]]) {\n    if (typeof value != \"string\" || value.length == 0 || value.trim() != value || [...value].length > 64 ||\n      !hasOnlyUnicodeScalars(value) || /[\\p{Cc}\\p{Zl}\\p{Zp}\\uFFFE\\uFFFF]/u.test(value)) {\n      invalidConfiguration(`${label} must be a non-empty single-line Unicode scalar string of at most 64 characters.`)\n    }\n  }\n  if (/[\\\\/:<>\"?*|]/u.test(productName)) {\n    invalidConfiguration(\"Product name contains a character forbidden by the Gradle project-name contract.\")\n  }\n  if (minimumSdk !== 23 || targetSdk !== 35 || compileSdk !== 35 || minimumSdk > targetSdk || targetSdk > compileSdk) {\n    invalidConfiguration(\"SDK levels must use the qualified minimum 23, target 35, and compile 35 matrix.\")\n  }\n  if (buildToolsVersion != toolchain.buildTools) invalidConfiguration(\"Build Tools version must be exactly '35.0.0'.\")\n  if (!Number.isSafeInteger(versionCode) || versionCode < 1 || versionCode > 2_100_000_000) {\n    invalidConfiguration(\"Version code must be a positive Android-safe integer.\")\n  }\n  if (typeof versionName != \"string\" || !semanticVersionPattern.test(versionName)) {\n    invalidConfiguration(\"Version name must be a canonical non-empty semantic version string.\")\n  }\n  if (orientation != \"unspecified\") invalidConfiguration(\"The baseline orientation is exactly 'unspecified'.\")\n  if (theme != \"system\") invalidConfiguration(\"The baseline theme is exactly 'system'.\")\n  if (configuration.permissions !== undefined &&\n    (!isDenseArray(configuration.permissions) || configuration.permissions.length != 0)) {\n    invalidConfiguration(\"The baseline Android permission set must be empty.\")\n  }\n\n  return {\n    activityClassName,\n    applicationId,\n    buildToolsVersion,\n    compileSdk,\n    displayName,\n    minimumSdk,\n    namespace,\n    orientation,\n    packageName,\n    productName,\n    targetSdk,\n    theme,\n    versionCode,\n    versionName\n  }\n}\n\n/**\n * Validates, snapshots, and orders caller-provided inputs.\n * @param {unknown} candidate - Candidate resource or asset list.\n * @param {\"asset\" | \"resource\"} kind - Android input kind.\n * @returns {AndroidInputFile[]} Normalized inputs.\n */\nfunction normalizeInputFiles(candidate, kind) {\n  if (candidate === undefined) return []\n  if (!isDenseArray(candidate)) invalidResource(`Application ${kind}s must be a dense array.`)\n  /** @type {AndroidInputFile[]} */\n  const files = []\n\n  for (let index = 0; index < candidate.length; index += 1) {\n    const item = candidate[index]\n\n    if (!isPlainObject(item) || Object.keys(item).length != resourceFields.size ||\n      Object.keys(item).some(key => !resourceFields.has(key))) invalidResource(`${capitalize(kind)} ${index} must use the closed input schema.`)\n    const path = item.path\n    const content = item.content\n    const mediaType = item.mediaType\n    const sha256 = item.sha256\n\n    if (!isSafeArtifactPath(path) || kind == \"resource\" && !isAllowedResourcePath(path)) {\n      invalidResource(`${capitalize(kind)} ${index} has an unsafe or unsupported path.`)\n    }\n    if (typeof content != \"string\" && !(content instanceof Uint8Array) || typeof content == \"string\" &&\n      (content.length == 0 || !hasOnlyUnicodeScalars(content)) || content instanceof Uint8Array && content.byteLength == 0) {\n      invalidResource(`${capitalize(kind)} '${path}' requires non-empty exact content.`)\n    }\n    if (typeof mediaType != \"string\" || !mediaTypePattern.test(mediaType) || /[\\r\\n]/u.test(mediaType)) {\n      invalidResource(`${capitalize(kind)} '${path}' requires an explicit valid media type.`)\n    }\n    if (kind == \"resource\" && path.startsWith(\"drawable-\") && ![\"image/png\", \"image/webp\"].includes(mediaType)) {\n      invalidResource(`Drawable resource '${path}' must use PNG or WebP media type.`)\n    }\n    const snapshot = typeof content == \"string\" ? content : new Uint8Array(content)\n    const actualHash = createHash(\"sha256\").update(snapshot).digest(\"hex\")\n\n    if (typeof sha256 != \"string\" || !/^[0-9a-f]{64}$/u.test(sha256) || sha256 != actualHash) {\n      invalidResource(`${capitalize(kind)} '${path}' SHA-256 does not match its exact content.`)\n    }\n    const fullPath = `${projectRoot}/app/src/main/${kind == \"resource\" ? \"res\" : \"assets\"}/${path}`\n\n    files.push({content: snapshot, contentKind: typeof snapshot == \"string\" ? \"text\" : \"binary\", fullPath, mediaType, path, sha256})\n  }\n  files.sort((left, right) => left.fullPath < right.fullPath ? -1 : left.fullPath > right.fullPath ? 1 : 0)\n  const conflict = findPortableArtifactPathConflict(files.map(({fullPath}) => fullPath))\n\n  if (conflict) invalidResource(`${capitalize(kind)} path '${conflict.path}' has a ${conflict.kind} conflict.`)\n  if (kind == \"resource\") validateResourceIdentifiers(files)\n\n  return files\n}\n\n/**\n * Rejects two files that Android would compile to the same resource identifier in one configuration.\n * @param {AndroidInputFile[]} files - Validated resource inputs.\n */\nfunction validateResourceIdentifiers(files) {\n  const identifiers = new Map()\n\n  for (const file of files) {\n    const separator = file.path.indexOf(\"/\")\n    const directory = file.path.slice(0, separator)\n    const filename = file.path.slice(separator + 1)\n    const extension = filename.indexOf(\".\")\n    const name = extension == -1 ? filename : filename.slice(0, extension)\n    const resourceType = directory.split(\"-\", 1)[0]\n    const key = `${directory}/${name}`\n    const previous = identifiers.get(key)\n\n    if (previous) {\n      invalidResource(`Android resource identifier '${resourceType}/${name}' collides between '${previous}' and '${file.path}' in configuration '${directory}'.`)\n    }\n    identifiers.set(key, file.path)\n  }\n}\n\n/**\n * Tests whether a caller resource uses the narrow allowlisted resource grammar.\n * @param {string} value - Resource path relative to res.\n * @returns {boolean} Whether the path is supported.\n */\nfunction isAllowedResourcePath(value) {\n  if (/^raw\\/[a-z][a-z0-9_]*(?:\\.[a-z0-9]+)?$/u.test(value)) return true\n\n  return /^drawable-(?:mdpi|hdpi|xhdpi|xxhdpi|xxxhdpi)\\/[a-z][a-z0-9_]*\\.(?:png|webp)$/u.test(value)\n}\n\n/**\n * Converts a validated input snapshot into an owned artifact.\n * @param {AndroidInputFile} item - Validated caller input.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Owned input artifact.\n */\nfunction inputFileArtifact(item) {\n  const reason = `Exact caller-provided Android input (sha256:${item.sha256}).`\n\n  if (typeof item.content == \"string\") {\n    return {\n      ...syntheticText(item.fullPath, \"resource\", item.content, reason),\n      mediaType: item.mediaType\n    }\n  }\n  const content = new Uint8Array(item.content)\n\n  return {\n    content,\n    contentKind: \"binary\",\n    mediaType: item.mediaType,\n    ownership: \"generated\",\n    path: item.fullPath,\n    provenance: {kind: \"bytes\", mapping: createByteMapping({\n      byteLength: content.byteLength,\n      path: item.fullPath,\n      ranges: [{generated: {end: content.byteLength, start: 0},\n        origin: {kind: \"synthetic\", reason, relatedOrigins: []}, role: \"resource\"}]\n    })},\n    role: \"resource\"\n  }\n}\n\n/**\n * Creates a deterministic synthetic text artifact.\n * @param {string} path - Artifact path.\n * @param {import(\"../semantic/types.js\").GeneratedArtifactRole} role - Artifact role.\n * @param {string} content - UTF-8 artifact content.\n * @param {string} reason - Synthetic provenance reason.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Text artifact.\n */\nfunction syntheticText(path, role, content, reason) {\n  return {content, contentKind: \"text\", mediaType: mediaTypeFor(path), ownership: \"generated\", path,\n    provenance: {kind: \"synthetic\", reason, relatedOrigins: []}, role}\n}\n\n/**\n * Creates a configuration-derived text artifact.\n * @param {string} path - Artifact path.\n * @param {import(\"../semantic/types.js\").GeneratedArtifactRole} role - Artifact role.\n * @param {string} content - UTF-8 artifact content.\n * @param {string} reason - Synthetic provenance reason.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Text artifact.\n */\nfunction configuredText(path, role, content, reason) {\n  return syntheticText(path, role, content, reason)\n}\n\n/**\n * Derives the media type for a generated text path.\n * @param {string} path - Generated artifact path.\n * @returns {string} Artifact media type.\n */\nfunction mediaTypeFor(path) {\n  if (path.endsWith(\".json\")) return \"application/json\"\n  if (path.endsWith(\".xml\")) return \"application/xml\"\n  if (path.endsWith(\".kt\") || path.endsWith(\".kts\")) return \"text/x-kotlin\"\n\n  return \"text/plain\"\n}\n\n/**\n * Marks one rendered value as configuration-derived.\n * @param {string} fieldName - Configuration field name.\n * @param {string} value - Rendered field value.\n * @returns {{field: string, value: string}} Marked configuration value.\n */\nfunction field(fieldName, value) {\n  return {field: fieldName, value}\n}\n\n/**\n * Joins rendered parts while recording configuration causality.\n * @param {string} path - Output artifact path.\n * @param {ConfigurationSpan[]} spans - Mutable provenance span collector.\n * @param {(string | {field: string, value: string})[]} parts - Synthetic and marked parts.\n * @returns {string} Rendered text.\n */\nfunction configured(path, spans, parts) {\n  let content = \"\"\n\n  for (const part of parts) {\n    if (typeof part == \"string\") content += part\n    else {\n      const start = content.length\n\n      content += part.value\n      spans.push({end: content.length, field: part.field, path, start})\n    }\n  }\n\n  return content\n}\n\n/**\n * Groups configuration spans by artifact.\n * @param {ConfigurationSpan[]} spans - All rendered configuration spans.\n * @param {string} fieldName - Requested configuration field.\n * @returns {{path: string, ranges: {end: number, start: number}[]}[]} Output ranges.\n */\nfunction configurationOutputs(spans, fieldName) {\n  const grouped = new Map()\n\n  for (const span of spans) {\n    if (span.field != fieldName) continue\n    const ranges = grouped.get(span.path) ?? []\n\n    ranges.push({end: span.end, start: span.start})\n    grouped.set(span.path, ranges)\n  }\n\n  return [...grouped].map(([path, ranges]) => ({path, ranges}))\n}\n\n/**\n * Tests whether a mapping origin refers to one semantic source file.\n * @param {import(\"../semantic/types.js\").SemanticOrigin} origin - Mapping origin.\n * @param {string} filename - Semantic source filename.\n * @returns {boolean} Whether the origin owns the filename.\n */\nfunction originReferencesFilename(origin, filename) {\n  if (origin.kind == \"source\") return origin.location.filename == filename\n  if (origin.kind == \"derived\") return origin.origins.some(({location}) => location.filename == filename)\n\n  return origin.relatedOrigins.some(({location}) => location.filename == filename)\n}\n\n/**\n * Hashes exact text or bytes for ownership records.\n * @param {string | Uint8Array} content - Exact artifact content.\n * @returns {string} Lowercase SHA-256 digest.\n */\nfunction hashContent(content) {\n  return createHash(\"sha256\").update(content).digest(\"hex\")\n}\n\n/**\n * Serializes JSON with recursively stable object-key ordering.\n * @param {unknown} value - JSON-compatible value.\n * @returns {string} Canonical indented JSON with trailing newline.\n */\nfunction stringifyCanonicalJson(value) {\n  return `${JSON.stringify(sortJson(value), null, 2)}\\n`\n}\n\n/**\n * Recursively sorts object keys without changing array order.\n * @param {unknown} value - JSON-compatible value.\n * @returns {unknown} Canonically ordered value.\n */\nfunction sortJson(value) {\n  if (Array.isArray(value)) return value.map(sortJson)\n  if (!isPlainObject(value)) return value\n\n  return Object.fromEntries(Object.keys(value).sort().map(key => [key, sortJson(value[key])]))\n}\n\n/**\n * Tests a lowercase Kotlin-compatible package identity.\n * @param {string} value - Candidate package name.\n * @returns {boolean} Whether the name is accepted.\n */\nfunction isPackageName(value) {\n  const parts = value.split(\".\")\n\n  return parts.length >= 2 && parts.every(part => /^[a-z][a-z0-9_]*$/u.test(part) && !kotlinKeywords.has(part))\n}\n\n/**\n * Rejects launcher names that shadow an unqualified symbol in generated same-package Kotlin.\n * @param {string} activityClassName - Validated launcher class name.\n * @param {string} entryModule - Selected semantic entry module.\n */\nfunction validateActivityClassName(activityClassName, entryModule) {\n  const semanticEntrySymbol = `SemantifoldModule${moduleName(entryModule)}`\n\n  if (androidScaffoldSymbols.has(activityClassName) || activityClassName == semanticEntrySymbol) {\n    invalidConfiguration(`Activity class name '${activityClassName}' collides with generated Kotlin symbol '${activityClassName}'.`)\n  }\n}\n\n/**\n * Allocates one module-wide output sink that cannot shadow a source binding.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Prepared semantic module.\n * @returns {string} Collision-safe Kotlin binding.\n */\nfunction outputSinkName(module) {\n  const bindings = new Set(module.functions.flatMap(declaration => declaration.parameters.map(({name}) => name)))\n\n  for (const declaration of module.functions) collectBlockBindingNames(declaration.body, bindings)\n  collectBlockBindingNames(module.entryPoint.body, bindings)\n  let candidate = \"semantifoldOutput\"\n\n  while (bindings.has(candidate)) candidate += \"_\"\n\n  return candidate\n}\n\n/**\n * Collects local bindings recursively from the supported semantic block subset.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @param {Set<string>} bindings - Mutable binding-name set.\n */\nfunction collectBlockBindingNames(block, bindings) {\n  for (const statement of block.statements) {\n    if (statement.kind == \"LocalDeclaration\") bindings.add(statement.name)\n    else if (statement.kind == \"IfStatement\") {\n      collectBlockBindingNames(statement.consequent, bindings)\n      if (statement.alternate) collectBlockBindingNames(statement.alternate, bindings)\n    }\n  }\n}\n\n/**\n * Maps a preflighted module identity to a stable Kotlin suffix.\n * @param {string} id - Semantic module identity.\n * @returns {string} Kotlin object-name suffix.\n */\nfunction moduleName(id) {\n  return id.split(/[._-]+/u).map(part => `${part[0].toUpperCase()}${part.slice(1)}`).join(\"\")\n}\n\n/**\n * Wraps legacy single-module input in the canonical program contract.\n * @param {import(\"../semantic/types.js\").SemanticModule | undefined} candidate - Candidate semantic module.\n * @returns {import(\"../semantic/types.js\").SemanticProgram} Canonical single-module program.\n */\nfunction normalizeSingleModule(candidate) {\n  if (!isPlainObject(candidate)) unsupportedCapability(\"android\", \"missing or invalid module\", undefined)\n  const module = structuredClone(candidate)\n  const sources = module.provenance?.sources\n\n  if (!Array.isArray(sources) || sources.length != 1 || sources[0].content === null ||\n    sources[0].filename != module.location?.filename || typeof sources[0].language != \"string\") {\n    unsupportedCapability(\"android\", \"single-module source ownership\", module.location)\n  }\n  rekeyModuleDeclarations(module, \"main\")\n  const exports = [\n    ...(module.records ?? []).map(declaration => applicationExport(declaration, \"record\")),\n    ...(module.classes ?? []).map(declaration => applicationExport(declaration, \"class\")),\n    ...(module.errors ?? []).map(declaration => applicationExport(declaration, \"error\")),\n    ...module.functions.map(declaration => applicationExport(declaration, \"function\"))\n  ]\n  const programModule = {...module, exports, id: \"main\", imports: [], sourceFilename: sources[0].filename}\n\n  return {entryModule: \"main\", kind: \"Program\", modules: [programModule], sources: structuredClone(sources)}\n}\n\n/**\n * Creates an application-local export record for single-module compatibility.\n * @param {{id?: string, location: import(\"../semantic/types.js\").SourceLocation, name: string}} declaration - Semantic declaration.\n * @param {import(\"../semantic/types.js\").SemanticDeclarationKind} symbolKind - Declaration kind.\n * @returns {import(\"../semantic/types.js\").SemanticExport} Semantic export.\n */\nfunction applicationExport(declaration, symbolKind) {\n  return {declarationId: /** @type {string} */ (declaration.id), exportedName: declaration.name,\n    kind: /** @type {const} */ (\"Export\"), location: declaration.location, symbolKind}\n}\n\n/**\n * Qualifies single-module declaration identities before program preflight.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Cloned semantic module.\n * @param {string} moduleId - Canonical module identity.\n */\nfunction rekeyModuleDeclarations(module, moduleId) {\n  const declarations = [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions]\n  const replacements = new Map(declarations.filter(declaration => typeof declaration.id == \"string\")\n    .map(declaration => [declaration.id, `${moduleId}#${declaration.id}`]))\n\n  for (const declaration of declarations) if (typeof declaration.id == \"string\") declaration.id = replacements.get(declaration.id)\n  const seen = new Set()\n  const identityFields = new Set([\"classId\", \"declarationId\", \"field\", \"method\", \"parameterId\"])\n  /**\n   * Rewrites declaration references throughout one semantic value graph.\n   * @param {unknown} value - Candidate nested semantic value.\n   */\n  const visit = value => {\n    if (!value || typeof value != \"object\" || seen.has(value)) return\n    seen.add(value)\n    for (const [key, nested] of Object.entries(value)) {\n      if (!Array.isArray(value) && identityFields.has(key) && typeof nested == \"string\" && replacements.has(nested)) {\n        Reflect.set(value, key, replacements.get(nested))\n      } else visit(nested)\n    }\n  }\n\n  visit(module)\n}\n\n/**\n * Escapes a configuration value for XML text or attributes.\n * @param {string} value - Raw configuration value.\n * @returns {string} XML-safe value.\n */\nfunction xmlEscape(value) {\n  return value.replaceAll(\"&\", \"&amp;\").replaceAll(\"<\", \"&lt;\").replaceAll(\">\", \"&gt;\")\n    .replaceAll('\"', \"&quot;\").replaceAll(\"'\", \"&apos;\")\n}\n\n/**\n * Escapes a configuration value for a Kotlin string literal body.\n * @param {string} value - Raw configuration value.\n * @returns {string} Kotlin-safe value.\n */\nfunction kotlinEscape(value) {\n  return value.replaceAll(\"\\\\\", \"\\\\\\\\\").replaceAll('\"', '\\\\\"').replaceAll(\"$\", \"\\\\$\")\n}\n\n/**\n * Uppercases the initial ASCII character of a known non-empty word.\n * @param {string} value - Non-empty word.\n * @returns {string} Capitalized word.\n */\nfunction capitalize(value) {\n  return `${value[0].toUpperCase()}${value.slice(1)}`\n}\n\n/**\n * Tests whether a value is a plain data object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return Boolean(value) && typeof value == \"object\" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Throws a stable invalid-request diagnostic.\n * @param {string} message - Diagnostic message.\n * @returns {never} Never returns.\n */\nfunction invalidInput(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_INPUT\", language: \"android\", message})\n}\n\n/**\n * Throws a stable invalid-configuration diagnostic.\n * @param {string} message - Diagnostic message.\n * @returns {never} Never returns.\n */\nfunction invalidConfiguration(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_CONFIGURATION\", language: \"android\", message})\n}\n\n/**\n * Throws a stable invalid-resource diagnostic.\n * @param {string} message - Diagnostic message.\n * @returns {never} Never returns.\n */\nfunction invalidResource(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_RESOURCE\", language: \"android\", message})\n}\n\n/**\n * Throws a stable invalid-path diagnostic.\n * @param {string} message - Diagnostic message.\n * @returns {never} Never returns.\n */\nfunction invalidPath(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_PATH\", language: \"android\", message})\n}\n"]}