semantifold 0.5.0 → 0.7.0

package/build/src/backends/flutter.js

@@ -0,0 +1,1362 @@
+// @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 { dartRuntime } from "./dart-runtime.js";
+import { emitDartBlock, findUnreadDartLocals } from "./dart.js";
+import { preflightSemanticProgram } from "./program.js";
+import { emitScalarType } from "./scalars.js";
+import { SourceWriter } from "./writer.js";
+const projectRoot = "generated/flutter-app";
+const generatorVersion = "0.6.0";
+const flutterToolchain = Object.freeze({
+    archive: "flutter_linux_3.47.4-stable.tar.xz",
+    archiveSha256: "5b45f0ceda99b9bebdc873e7e69f6450aeb4c30f454b505e2e62fc9255a907d3",
+    dart: "3.13.3",
+    revision: "9584c6713b324636289d067944a46fd6b49df14b",
+    version: "3.47.4"
+});
+const androidToolchain = Object.freeze({
+    androidGradlePlugin: "8.11.1",
+    buildTools: "35.0.0",
+    cmake: "3.22.1",
+    compileSdk: 35,
+    gradle: "8.14",
+    java: "21.0.8",
+    kotlinGradlePlugin: "2.2.20",
+    minimumSdk: 23,
+    ndk: "27.0.12077973",
+    targetSdk: 35
+});
+/** @type {readonly (readonly [string, string, string])[]} */
+const flutterLockedHostedPackages = Object.freeze([
+    ["async", "2.13.1", "e2eb0491ba5ddb6177742d2da23904574082139b07c1e33b8503b9f46f3e1a37"],
+    ["boolean_selector", "2.1.2", "8aab1771e1243a5063b8b0ff68042d67334e3feab9e95b9490f9a6ebf73b42ea"],
+    ["characters", "1.4.1", "faf38497bda5ead2a8c7615f4f7939df04333478bf32e4173fcb06d428b5716b"],
+    ["clock", "1.1.3", "e51d50bca3217c9a9fa2b41a30e4a38971133f5f9ec7a3d57bae095007f1d28e"],
+    ["collection", "1.19.1", "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76"],
+    ["fake_async", "1.3.3", "5368f224a74523e8d2e7399ea1638b37aecfca824a3cc4dfdf77bf1fa905ac44"],
+    ["leak_tracker", "11.0.2", "33e2e26bdd85a0112ec15400c8cbffea70d0f9c3407491f672a2fad47915e2de"],
+    ["leak_tracker_flutter_testing", "3.0.10", "1dbc140bb5a23c75ea9c4811222756104fbcd1a27173f0c34ca01e16bea473c1"],
+    ["leak_tracker_testing", "3.0.2", "8d5a2d49f4a66b49744b23b018848400d23e54caf9463f4eb20df3eb8acb2eb1"],
+    ["matcher", "0.12.20", "31bd099b47c10cd1aeb55146a2d46ce0277630ecef3f7dae54ad7873f36696cd"],
+    ["material_color_utilities", "0.13.0", "9c337007e82b1889149c82ed242ed1cb24a66044e30979c44912381e9be4c48b"],
+    ["meta", "1.19.0", "307249ce4ff29d58a18e97f6345f539382eb9c9c29ecda628900f31de0443dd9"],
+    ["path", "1.9.1", "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5"],
+    ["source_span", "1.10.2", "56a02f1f4cd1a2d96303c0144c93bd6d909eea6bee6bf5a0e0b685edbd4c47ab"],
+    ["stack_trace", "1.12.2", "277654b3034d17ac6f9f1cb5595db011b1d5d41e8806866db28e0abaa101c490"],
+    ["stream_channel", "2.1.4", "969e04c80b8bcdf826f8f16579c7b14d780458bd97f56d107d3950fdbeef059d"],
+    ["string_scanner", "1.4.1", "921cd31725b72fe181906c6a94d987c78e3b98c2e205b397ea399d4054872b43"],
+    ["term_glyph", "1.2.2", "7f554798625ea768a7518313e58f83891c7f5024f88e46e7182a4558850a4b8e"],
+    ["test_api", "0.7.12", "2a122cbe059f8b610d3a5415f42e255b6c17b1f21eee1d960f31080237fb4f11"],
+    ["vector_math", "2.4.2", "f36f9f3be64c6198714492bb455c11056e33e2f85d9a0b676a48301e44fdcf47"],
+    ["vm_service", "15.3.0", "5f37239c4851efcef929cea7824e76df7f2f0970aef85d66bbc430afa40e72f0"]
+]);
+/** @type {readonly (readonly [string, "direct main" | "direct dev" | "transitive"])[]} */
+const flutterLockedSdkPackages = Object.freeze([
+    ["flutter", "direct main"],
+    ["flutter_test", "direct dev"],
+    ["sky_engine", "transitive"]
+]);
+/** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
+const flutterSourceLanguages = new Set([
+    "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart", "zig"
+]);
+const requestFields = new Set(["assets", "configuration", "language", "module", "program", "role"]);
+const configurationFields = new Set([
+    "activityClassName", "applicationId", "buildToolsVersion", "compileSdk", "displayName", "minimumSdk", "organization",
+    "packageName", "permissions", "targetSdk", "versionCode", "versionName"
+]);
+const assetFields = new Set(["content", "mediaType", "path", "sha256"]);
+const dartKeywords = new Set([
+    "abstract", "as", "assert", "async", "await", "base", "break", "case", "catch", "class", "const", "continue",
+    "covariant", "default", "deferred", "do", "dynamic", "else", "enum", "export", "extends", "extension", "external",
+    "factory", "false", "final", "finally", "for", "Function", "get", "hide", "if", "implements", "import", "in",
+    "interface", "is", "late", "library", "mixin", "new", "null", "of", "on", "operator", "part", "required",
+    "rethrow", "return", "sealed", "set", "show", "static", "super", "switch", "sync", "this", "throw", "true",
+    "try", "typedef", "var", "void", "when", "while", "with", "yield"
+]);
+const javaKeywords = new Set([
+    "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "default",
+    "do", "double", "else", "enum", "extends", "final", "finally", "float", "for", "goto", "if", "implements",
+    "import", "instanceof", "int", "interface", "long", "native", "new", "package", "private", "protected", "public",
+    "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient",
+    "try", "void", "volatile", "while"
+]);
+const forbiddenPackageNames = new Set([
+    ...flutterLockedHostedPackages.map(([name]) => name),
+    ...flutterLockedSdkPackages.map(([name]) => name),
+    "integration_test",
+    "semantifold"
+]);
+const androidRunnerBaseClassNames = new Set(["FlutterActivity"]);
+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 mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+(?:[\u0020-\u007e]+)?$/u;
+const excludedPathPatterns = Object.freeze([
+    ".dart_tool/**", ".flutter-plugins", ".flutter-plugins-dependencies", "android/.gradle/**", "android/app/build/**",
+    "android/local.properties", "build/**"
+]);
+const outputSinkRuntime = `
+final class _SemantifoldOutputSink {
+  final List<String> _values = <String>[];
+
+  void write(Object value) {
+    if (value is! int && value is! bool && value is! String) {
+      throw StateError('Unsupported Semantifold output value');
+    }
+    _values.add(value.toString());
+  }
+
+  List<String> snapshot() => List<String>.unmodifiable(_values);
+}
+`;
+/** @typedef {{content: string | Uint8Array, contentKind: "binary" | "text", fullPath: string, mediaType: string, path: string, sha256: string}} FlutterAsset */
+/** @typedef {{end: number, field: string, path: string, start: number}} ConfigurationSpan */
+/**
+ * Preflights a complete Flutter application request before rendering any artifact.
+ * @param {Record<string, unknown>} input - Candidate application request.
+ * @returns {{assets: FlutterAsset[], configuration: import("../semantic/types.js").FlutterApplicationConfiguration, modulePaths: Map<string, string>, modules: import("../semantic/types.js").SemanticModule[], packagePath: string, program: import("../semantic/types.js").SemanticProgram, sources: {content: string, filename: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} Prepared application.
+ */
+export function preflightFlutterApplication(input) {
+    if (!isPlainObject(input) || Object.keys(input).some(key => !requestFields.has(key)) ||
+        Boolean(input.module) == Boolean(input.program)) {
+        invalidInput("Flutter application generation requires a closed request with exactly one semantic module or program.");
+    }
+    if (input.language !== undefined && input.language != "flutter" || input.role !== undefined && input.role != "application") {
+        invalidInput("Flutter application generation accepts only the Flutter 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: "dart",
+        diagnosticLanguage: "flutter",
+        program: /** @type {import("../semantic/types.js").SemanticProgram} */ (program),
+        sourceLanguages: flutterSourceLanguages
+    });
+    const entryModule = prepared.modules.find(module => Reflect.get(module, "id") == prepared.program.entryModule);
+    const entryCollision = entryModule?.functions.find(({ name }) => name == "semantifoldEntry");
+    if (entryCollision)
+        unsupportedCapability("flutter", "reserved generated semantic entry function 'semantifoldEntry'", entryCollision.location);
+    const packagePath = configuration.applicationId.replaceAll(".", "/");
+    const modulePaths = new Map(prepared.modules.map(module => {
+        const moduleId = /** @type {string} */ (Reflect.get(module, "id"));
+        return [moduleId, `${projectRoot}/lib/src/semantic/${moduleFileName(moduleId)}.dart`];
+    }));
+    const assets = normalizeAssets(input.assets);
+    const completePaths = [...applicationPaths(configuration, modulePaths), ...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}'` : ""}.`);
+    }
+    const semanticNames = new Map();
+    for (const module of prepared.modules) {
+        const moduleId = /** @type {string} */ (Reflect.get(module, "id"));
+        const name = moduleName(moduleId);
+        const previous = semanticNames.get(name);
+        if (previous)
+            invalidPath(`Semantic modules '${previous}' and '${moduleId}' collide at generated Dart class '${name}'.`);
+        semanticNames.set(name, moduleId);
+    }
+    return { ...prepared, assets, configuration, modulePaths, packagePath };
+}
+/**
+ * Generates one deterministic SDK-only Flutter project for the qualified Android lane.
+ * @param {Record<string, unknown>} input - Application generation request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], metadata: {applicationManifest: string, platformQualification: {android: string, ios: string}}, target: "flutter"}} Candidate artifact set.
+ */
+export function generateFlutterApplication(input) {
+    const prepared = preflightFlutterApplication(input);
+    const configurationSpans = /** @type {ConfigurationSpan[]} */ ([]);
+    const configuration = prepared.configuration;
+    const semanticArtifacts = renderSemanticArtifacts(prepared);
+    const artifacts = /** @type {import("../semantic/types.js").GeneratedSetArtifact[]} */ ([
+        syntheticText(`${projectRoot}/.metadata`, "manifest", renderMetadata(), "Exact Flutter 3.47.4 project-template identity; generated migration is disabled."),
+        syntheticText(`${projectRoot}/analysis_options.yaml`, "support", renderAnalysisOptions(), "Closed analyzer configuration without external lint packages."),
+        configuredText(`${projectRoot}/android/app/build.gradle.kts`, "manifest", renderAndroidAppBuild(configuration, configurationSpans), "Task 028-compatible Android build and isolated debug-signing configuration."),
+        configuredText(`${projectRoot}/android/app/src/main/AndroidManifest.xml`, "manifest", renderAndroidManifest(configuration, configurationSpans), "Closed permission-free Flutter Android application manifest."),
+        configuredText(`${projectRoot}/android/app/src/main/java/${prepared.packagePath}/${configuration.activityClassName}.java`, "support", renderAndroidActivity(configuration, configurationSpans), "Synthetic Flutter Android embedding launcher."),
+        syntheticText(`${projectRoot}/android/app/src/main/res/drawable/launch_background.xml`, "resource", renderLaunchBackground(), "Synthetic minimum-SDK-qualified Flutter launch background."),
+        syntheticText(`${projectRoot}/android/app/src/main/res/values-night/styles.xml`, "resource", renderAndroidStyles(true), "Synthetic dark platform launch and Flutter host themes."),
+        syntheticText(`${projectRoot}/android/app/src/main/res/values/styles.xml`, "resource", renderAndroidStyles(false), "Synthetic light platform launch and Flutter host themes."),
+        syntheticText(`${projectRoot}/android/app/src/main/res/xml/backup_rules.xml`, "resource", renderBackupRules(), "Closed API 23-30 full-backup exclusions reused from the Android safety contract."),
+        syntheticText(`${projectRoot}/android/app/src/main/res/xml/data_extraction_rules.xml`, "resource", renderDataExtractionRules(), "Closed Android 12+ backup and transfer exclusions reused from the Android safety contract."),
+        syntheticText(`${projectRoot}/android/build.gradle.kts`, "manifest", renderAndroidRootBuild(), "Task 028-compatible deterministic Android root build."),
+        syntheticText(`${projectRoot}/android/gradle.properties`, "support", renderAndroidGradleProperties(), "Pinned isolated Gradle properties for the qualified Android lane."),
+        configuredText(`${projectRoot}/android/settings.gradle.kts`, "manifest", renderAndroidSettings(configuration, configurationSpans), "Exact Flutter Gradle plugin loader with the pinned Task 028 Android plugin matrix."),
+        configuredText(`${projectRoot}/lib/main.dart`, "entry", renderWidgetApplication(prepared, configurationSpans), "Synthetic stateless Material application and labelled output widget."),
+        ...semanticArtifacts,
+        syntheticText(`${projectRoot}/pubspec.lock`, "manifest", renderPubspecLock(), "Exact Flutter 3.47.4 SDK dependency resolution; no caller package resolution."),
+        configuredText(`${projectRoot}/pubspec.yaml`, "manifest", renderPubspec(prepared, configurationSpans), "Closed SDK-only Flutter package and asset manifest."),
+        configuredText(`${projectRoot}/test/semantic_logic_test.dart`, "support", renderLogicTest(prepared, configurationSpans), "SDK-owned Flutter test for fresh deterministic semantic entry execution."),
+        configuredText(`${projectRoot}/test/widget_test.dart`, "support", renderWidgetTest(prepared, configurationSpans), "SDK-owned Flutter widget test for exact text, key, and semantics label."),
+        ...prepared.assets.map(assetArtifact)
+    ]);
+    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 Flutter project ownership, toolchain, provenance, and platform-status manifest."));
+    return {
+        artifacts,
+        metadata: {
+            applicationManifest: manifestPath,
+            platformQualification: { android: "tensorbuzz-kvm", ios: "deferred-owner-direction" }
+        },
+        target: "flutter"
+    };
+}
+/**
+ * Emits mapped application-owned Dart semantic modules.
+ * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared application.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact[]} Semantic Dart artifacts.
+ */
+function renderSemanticArtifacts(prepared) {
+    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"))
+            });
+    }
+    /** @type {import("../semantic/types.js").GeneratedSetArtifact[]} */
+    const artifacts = [syntheticText(`${projectRoot}/lib/src/semantic/semantifold.dart`, "support", renderSemanticLibrary(prepared), "Shared checked Dart scalar/output runtime and deterministic part ownership.")];
+    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 Flutter function '${expression.resolution?.declarationId}'.`);
+                return `SemantifoldModule${moduleName(resolved.moduleId)}.${resolved.declaration.name}`;
+            },
+            filename,
+            language: "dart",
+            module,
+            program: prepared.program,
+            programPaths: prepared.modulePaths,
+            sources: prepared.sources
+        });
+        writer.synthetic("part of 'semantifold.dart';\n\n", "Flutter semantic library part directive", [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-dart",
+            ownership: "generated",
+            path: filename,
+            provenance: { kind: "text", mapping, sourceMap: toSourceMapV3(mapping), sourceMapFilename: `${filename}.map` },
+            role: "source"
+        });
+    }
+    return artifacts;
+}
+/**
+ * Emits one namespaced semantic Dart part.
+ * @param {SourceWriter} writer - Mapped source writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Prepared semantic module.
+ * @param {string} moduleId - Stable semantic module identity.
+ * @param {boolean} entry - Whether this module owns the application entry.
+ * @param {string} sinkName - Collision-safe output sink binding.
+ */
+function emitSemanticModule(writer, module, moduleId, entry, sinkName) {
+    const unreadLocals = findUnreadDartLocals(module);
+    writer.synthetic(`abstract final class SemantifoldModule${moduleName(moduleId)} {\n`, "Flutter semantic module namespace", [module], [""]);
+    module.functions.forEach((declaration, functionIndex) => {
+        const path = `/functions/${functionIndex}`;
+        writer.synthetic("  static ", "Flutter namespaced function scaffold", [declaration], [path]);
+        writer.mapped(emitScalarType("dart", declaration.returnType), {
+            mappingKind: "exact", node: declaration.returnType, path: `${path}/returnType`, role: "type"
+        });
+        writer.synthetic(" ", "declaration spacing", [declaration], [path]);
+        writer.mapped(declaration.name, { mappingKind: "exact", node: declaration, path, role: "name" });
+        const parameterTexts = declaration.parameters.map(parameter => `${emitScalarType("dart", parameter.type)} ${parameter.name}`);
+        parameterTexts.push(`_SemantifoldOutputSink ${sinkName}`);
+        const multiline = writer.column - 1 + `(${parameterTexts.join(", ")}) {`.length > 80;
+        writer.mapped("(", { mappingKind: "anchor", node: declaration, path });
+        declaration.parameters.forEach((parameter, parameterIndex) => {
+            const parameterPath = `${path}/parameters/${parameterIndex}`;
+            if (multiline)
+                writer.synthetic(`${parameterIndex ? "" : "\n"}    `, "Dart application parameter indentation", [parameter], [parameterPath]);
+            else if (parameterIndex)
+                writer.synthetic(", ", "parameter separator", [parameter], [parameterPath]);
+            writer.mapped(emitScalarType("dart", parameter.type), {
+                mappingKind: "exact", node: parameter.type, path: `${parameterPath}/type`, role: "type"
+            });
+            writer.synthetic(" ", "parameter spacing", [parameter], [parameterPath]);
+            writer.mapped(parameter.name, { mappingKind: "exact", node: parameter, path: parameterPath, role: "name" });
+            if (multiline)
+                writer.synthetic(",\n", "Dart formatter parameter separator", [parameter], [parameterPath]);
+        });
+        if (multiline)
+            writer.synthetic(`${declaration.parameters.length ? "" : "\n"}    _SemantifoldOutputSink ${sinkName},\n  `, "Flutter output sink parameter", [declaration], [path]);
+        else
+            writer.synthetic(`${declaration.parameters.length ? ", " : ""}_SemantifoldOutputSink ${sinkName}`, "Flutter output sink parameter", [declaration], [path]);
+        writer.mapped(")", { mappingKind: "anchor", node: declaration, path });
+        writer.synthetic(" {\n", "Dart function body scaffold", [declaration], [path]);
+        emitDartBlock(writer, declaration.body, "    ", `${path}/body`, unreadLocals, `${sinkName}.write`, true);
+        writer.synthetic("  }\n", "Dart function body scaffold", [declaration], [path]);
+        if (functionIndex + 1 < module.functions.length || entry) {
+            writer.synthetic("\n", "Dart formatter declaration separator", [declaration], [path]);
+        }
+    });
+    if (entry) {
+        writer.synthetic("  static List<String> semantifoldEntry() {\n", "Flutter semantic entry scaffold", [module.entryPoint], ["/entryPoint"]);
+        writer.synthetic(`    final _SemantifoldOutputSink ${sinkName} = _SemantifoldOutputSink();\n`, "Flutter output sink allocation", [module.entryPoint], ["/entryPoint"]);
+        emitDartBlock(writer, module.entryPoint.body, "    ", "/entryPoint/body", unreadLocals, `${sinkName}.write`, true);
+        writer.synthetic(`    return ${sinkName}.snapshot();\n`, "Flutter semantic output return", [module.entryPoint], ["/entryPoint"]);
+        writer.synthetic("  }\n", "Flutter semantic entry scaffold", [module.entryPoint], ["/entryPoint"]);
+    }
+    writer.synthetic("}\n", "Flutter semantic module namespace", [module], [""]);
+}
+/**
+ * Renders the shared semantic Dart library.
+ * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.
+ * @returns {string} Dart library source.
+ */
+function renderSemanticLibrary(prepared) {
+    const parts = prepared.modules.map(module => `part '${moduleFileName(/** @type {string} */ (Reflect.get(module, "id")))}.dart';`).join("\n");
+    return `${parts}\n\n${dartRuntime}${outputSinkRuntime}`;
+}
+/**
+ * Renders exact Flutter template identity metadata.
+ * @returns {string} Metadata YAML.
+ */
+function renderMetadata() {
+    return `# This file tracks properties of this Semantifold-owned Flutter project.
+version:
+  revision: ${flutterToolchain.revision}
+  channel: stable
+project_type: app
+`;
+}
+/**
+ * Renders the closed analyzer configuration.
+ * @returns {string} Analyzer YAML.
+ */
+function renderAnalysisOptions() {
+    return `analyzer:
+  language:
+    strict-casts: true
+    strict-raw-types: true
+`;
+}
+/**
+ * Renders the SDK-only package manifest.
+ * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @returns {string} Pubspec YAML.
+ */
+function renderPubspec(prepared, spans) {
+    const configuration = prepared.configuration;
+    const assetLines = prepared.assets.length == 0 ? "" : `\n  assets:\n${prepared.assets.map(({ path }) => `    - ${path}`).join("\n")}\n`;
+    return configured(`${projectRoot}/pubspec.yaml`, spans, [
+        "name: ", field("packageName", configuration.packageName), "\npublish_to: none\nversion: ",
+        field("versionName", configuration.versionName), "+", field("versionCode", String(configuration.versionCode)),
+        "\nenvironment:\n  sdk: 3.13.3\n  flutter: 3.47.4\ndependencies:\n  flutter:\n    sdk: flutter\ndev_dependencies:\n  flutter_test:\n    sdk: flutter\nflutter:\n  uses-material-design: true\n",
+        assetLines
+    ]);
+}
+/**
+ * Renders the exact Flutter SDK dependency lock.
+ * @returns {string} Pub lock YAML.
+ */
+function renderPubspecLock() {
+    const hosted = new Map(flutterLockedHostedPackages.map(package_ => [package_[0], package_]));
+    const sdk = new Map(flutterLockedSdkPackages);
+    const packageNames = [...hosted.keys(), ...sdk.keys()].sort();
+    const packages = packageNames.map(name => {
+        const sdkDependency = sdk.get(name);
+        if (sdkDependency)
+            return `  ${name}:
+    dependency: ${sdkDependency == "transitive" ? sdkDependency : `"${sdkDependency}"`}
+    description: flutter
+    source: sdk
+    version: "0.0.0"`;
+        const locked = hosted.get(name);
+        if (!locked)
+            throw new TypeError(`Missing validated Flutter lock entry '${name}'.`);
+        const [, version, sha256] = locked;
+        const renderedHash = /^[0-9]/u.test(sha256) ? `"${sha256}"` : sha256;
+        return `  ${name}:
+    dependency: transitive
+    description:
+      name: ${name}
+      sha256: ${renderedHash}
+      url: "https://pub.dev"
+    source: hosted
+    version: "${version}"`;
+    }).join("\n");
+    return `# Generated by pub
+# See https://dart.dev/tools/pub/glossary#lockfile
+packages:
+${packages}
+sdks:
+  dart: "3.13.3"
+  flutter: "3.47.4"
+`;
+}
+/**
+ * Renders the synthetic Material widget shell.
+ * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @returns {string} Flutter entry source.
+ */
+function renderWidgetApplication(prepared, spans) {
+    const entryClass = `SemantifoldModule${moduleName(prepared.program.entryModule)}`;
+    return configured(`${projectRoot}/lib/main.dart`, spans, [
+        `import 'package:flutter/material.dart';
+
+import 'src/semantic/semantifold.dart';
+
+void main() {
+  runApp(const SemantifoldApplication());
+}
+
+class SemantifoldApplication extends StatelessWidget {
+  const SemantifoldApplication({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final List<String> lines = ${entryClass}.semantifoldEntry();
+
+    return MaterialApp(
+      debugShowCheckedModeBanner: false,
+      title: '`, field("displayName", dartEscape(prepared.configuration.displayName)), `',
+      home: Scaffold(
+        body: Center(
+          child: Semantics(
+            key: const Key('semantifold-output'),
+            container: true,
+            explicitChildNodes: true,
+            label: 'semantifold-output',
+            child: Text(lines.join('\\n')),
+          ),
+        ),
+      ),
+    );
+  }
+}
+`
+    ]);
+}
+/**
+ * Renders the semantic-entry determinism test.
+ * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @returns {string} Flutter test source.
+ */
+function renderLogicTest(prepared, spans) {
+    const entryClass = `SemantifoldModule${moduleName(prepared.program.entryModule)}`;
+    return configured(`${projectRoot}/test/semantic_logic_test.dart`, spans, [
+        "import 'package:flutter_test/flutter_test.dart';\nimport 'package:", field("packageName", prepared.configuration.packageName),
+        `/src/semantic/semantifold.dart';
+
+void main() {
+  test('semantic entry is deterministic across fresh runs', () {
+    expect(
+      ${entryClass}.semantifoldEntry(),
+      ${entryClass}.semantifoldEntry(),
+    );
+  });
+}
+`
+    ]);
+}
+/**
+ * Renders the exact labelled widget test.
+ * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @returns {string} Flutter widget test source.
+ */
+function renderWidgetTest(prepared, spans) {
+    const entryClass = `SemantifoldModule${moduleName(prepared.program.entryModule)}`;
+    return configured(`${projectRoot}/test/widget_test.dart`, spans, [
+        "import 'package:flutter/material.dart';\nimport 'package:flutter_test/flutter_test.dart';\nimport 'package:",
+        field("packageName", prepared.configuration.packageName), `/main.dart';
+import 'package:`, field("packageName", prepared.configuration.packageName), `/src/semantic/semantifold.dart';
+
+void main() {
+  testWidgets('renders exact labelled semantic output', (
+    WidgetTester tester,
+  ) async {
+    final String expected = ${entryClass}.semantifoldEntry().join('\\n');
+
+    await tester.pumpWidget(const SemantifoldApplication());
+    final Finder output = find.byKey(const Key('semantifold-output'));
+
+    expect(output, findsOneWidget);
+    expect(
+      tester.widget<Semantics>(output).properties.label,
+      'semantifold-output',
+    );
+    expect(
+      find.descendant(of: output, matching: find.text(expected)),
+      findsOneWidget,
+    );
+  });
+}
+`
+    ]);
+}
+/**
+ * Renders the shared Android root build.
+ * @returns {string} Gradle Kotlin source.
+ */
+function renderAndroidRootBuild() {
+    return `allprojects {
+  repositories {
+    google()
+    mavenCentral()
+  }
+}
+
+val newBuildDir: Directory = rootProject.layout.buildDirectory.dir("../../build").get()
+rootProject.layout.buildDirectory.value(newBuildDir)
+
+subprojects {
+  project.layout.buildDirectory.value(newBuildDir.dir(project.name))
+  project.evaluationDependsOn(":app")
+}
+
+tasks.register<Delete>("clean") {
+  delete(rootProject.layout.buildDirectory)
+}
+`;
+}
+/**
+ * Renders Flutter plugin and Android plugin ownership.
+ * @param {import("../semantic/types.js").FlutterApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @returns {string} Gradle settings source.
+ */
+function renderAndroidSettings(configuration, spans) {
+    return configured(`${projectRoot}/android/settings.gradle.kts`, spans, [`pluginManagement {
+  val flutterSdkPath = run {
+    val properties = java.util.Properties()
+    file("local.properties").inputStream().use { properties.load(it) }
+    requireNotNull(properties.getProperty("flutter.sdk")) { "flutter.sdk not set in local.properties" }
+  }
+
+  includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")
+
+  repositories {
+    google()
+    mavenCentral()
+    gradlePluginPortal()
+  }
+}
+
+plugins {
+  id("dev.flutter.flutter-plugin-loader") version "1.0.0"
+  id("com.android.application") version "${androidToolchain.androidGradlePlugin}" apply false
+  id("org.jetbrains.kotlin.android") version "${androidToolchain.kotlinGradlePlugin}" apply false
+}
+
+rootProject.name = "`, field("packageName", configuration.packageName), `"
+include(":app")
+`]);
+}
+/**
+ * Renders deterministic Android Gradle properties.
+ * @returns {string} Gradle properties.
+ */
+function renderAndroidGradleProperties() {
+    return `android.builtInKotlin=false
+android.newDsl=false
+android.useAndroidX=true
+kotlin.stdlib.default.dependency=false
+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
+`;
+}
+/**
+ * Renders the Flutter Android application build.
+ * @param {import("../semantic/types.js").FlutterApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @returns {string} Application Gradle source.
+ */
+function renderAndroidAppBuild(configuration, spans) {
+    return configured(`${projectRoot}/android/app/build.gradle.kts`, spans, [`plugins {
+  id("com.android.application")
+  id("org.jetbrains.kotlin.android")
+  id("dev.flutter.flutter-gradle-plugin")
+}
+
+val semantifoldAcceptanceRoot = providers.environmentVariable("SEMANTIFOLD_FLUTTER_ACCEPTANCE_ROOT").orNull
+  ?: throw GradleException("SEMANTIFOLD_FLUTTER_INFRASTRUCTURE: SEMANTIFOLD_FLUTTER_ACCEPTANCE_ROOT is required")
+val semantifoldDebugKeystore = file("$semantifoldAcceptanceRoot/debug.keystore")
+if (!semantifoldDebugKeystore.isFile) {
+  throw GradleException("SEMANTIFOLD_FLUTTER_INFRASTRUCTURE: ephemeral debug keystore is missing")
+}
+
+configurations.configureEach {
+  exclude(group = "androidx.profileinstaller", module = "profileinstaller")
+}
+
+android {
+  namespace = "`, field("applicationId", configuration.applicationId), `"
+  compileSdk = `, field("compileSdk", String(configuration.compileSdk)), `
+  buildToolsVersion = "`, field("buildToolsVersion", configuration.buildToolsVersion), `"
+  ndkVersion = "${androidToolchain.ndk}"
+
+  defaultConfig {
+    applicationId = "`, field("applicationId", configuration.applicationId), `"
+    minSdk = `, field("minimumSdk", String(configuration.minimumSdk)), `
+    targetSdk = `, field("targetSdk", String(configuration.targetSdk)), `
+    versionCode = `, field("versionCode", String(configuration.versionCode)), `
+    versionName = "`, field("versionName", configuration.versionName), `"
+  }
+
+  signingConfigs {
+    getByName("debug") {
+      storeFile = semantifoldDebugKeystore
+      storePassword = "android"
+      keyAlias = "androiddebugkey"
+      keyPassword = "android"
+    }
+  }
+
+  buildTypes {
+    getByName("debug") {
+      signingConfig = signingConfigs.getByName("debug")
+    }
+  }
+
+  buildFeatures {
+    buildConfig = false
+  }
+
+  compileOptions {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+  }
+
+  lint {
+    abortOnError = true
+    checkDependencies = true
+    disable += "MissingApplicationIcon"
+    disable += "OldTargetApi"
+    disable += "GradleDependency"
+    warningsAsErrors = true
+  }
+}
+
+flutter {
+  source = "../.."
+}
+`]);
+}
+/**
+ * Renders the permission-free Android manifest.
+ * @param {import("../semantic/types.js").FlutterApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @returns {string} Android manifest XML.
+ */
+function renderAndroidManifest(configuration, spans) {
+    return configured(`${projectRoot}/android/app/src/main/AndroidManifest.xml`, spans, [
+        `<manifest
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools">
+  <permission tools:node="removeAll" />
+  <uses-permission tools:node="removeAll" />
+  <application
+    android:allowBackup="false"
+    android:dataExtractionRules="@xml/data_extraction_rules"
+    android:fullBackupContent="@xml/backup_rules"
+    android:label="`, field("displayName", xmlEscape(configuration.displayName)), `"
+    android:name="\${applicationName}"
+    android:supportsRtl="true">
+    <activity
+      android:name=".`, field("activityClassName", configuration.activityClassName), `"
+      android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
+      android:exported="true"
+      android:hardwareAccelerated="true"
+      android:launchMode="singleTop"
+      android:taskAffinity=""
+      android:theme="@style/LaunchTheme"
+      android:windowSoftInputMode="adjustResize">
+      <meta-data
+        android:name="io.flutter.embedding.android.NormalTheme"
+        android:resource="@style/NormalTheme" />
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+    <meta-data android:name="flutterEmbedding" android:value="2" />
+    <provider android:name="androidx.startup.InitializationProvider" tools:node="remove" />
+  </application>
+</manifest>
+`
+    ]);
+}
+/**
+ * Renders the Java Flutter activity launcher.
+ * @param {import("../semantic/types.js").FlutterApplicationConfiguration} configuration - Normalized configuration.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @returns {string} Java source.
+ */
+function renderAndroidActivity(configuration, spans) {
+    return configured(`${projectRoot}/android/app/src/main/java/${configuration.applicationId.replaceAll(".", "/")}/${configuration.activityClassName}.java`, spans, [
+        "package ", field("applicationId", configuration.applicationId), `;
+
+import io.flutter.embedding.android.FlutterActivity;
+
+public final class `, field("activityClassName", configuration.activityClassName), ` extends FlutterActivity {
+}
+`
+    ]);
+}
+/**
+ * Renders platform launch and host styles.
+ * @param {boolean} night - Whether to render the night theme.
+ * @returns {string} Android resource XML.
+ */
+function renderAndroidStyles(night) {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <style name="LaunchTheme" parent="@android:style/Theme.${night ? "Black" : "Light"}.NoTitleBar">
+    <item name="android:windowBackground">@drawable/launch_background</item>
+  </style>
+  <style name="NormalTheme" parent="@android:style/Theme.${night ? "Black" : "Light"}.NoTitleBar">
+    <item name="android:windowBackground">?android:colorBackground</item>
+  </style>
+</resources>
+`;
+}
+/**
+ * Renders a platform launch background.
+ * @returns {string} Android resource XML.
+ */
+function renderLaunchBackground() {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:drawable="?android:colorBackground" />
+</layer-list>
+`;
+}
+/**
+ * Renders complete legacy backup exclusions.
+ * @returns {string} Android resource 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 complete Android 12+ backup exclusions.
+ * @returns {string} Android resource XML.
+ */
+function renderDataExtractionRules() {
+    const exclusions = ["root", "file", "database", "sharedpref", "external", "device_root", "device_file", "device_database", "device_sharedpref"]
+        .map(domain => `    <exclude domain="${domain}" path="." />`).join("\n");
+    return `<?xml version="1.0" encoding="utf-8"?>
+<data-extraction-rules>
+  <cloud-backup>
+${exclusions}
+  </cloud-backup>
+  <device-transfer>
+${exclusions}
+  </device-transfer>
+</data-extraction-rules>
+`;
+}
+/**
+ * Renders the ownership, toolchain, provenance, and platform-status manifest.
+ * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared application.
+ * @param {import("../semantic/types.js").GeneratedSetArtifact[]} artifacts - Owned artifacts except this manifest.
+ * @param {string} manifestPath - Manifest artifact path.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance spans.
+ * @returns {string} Canonical manifest JSON.
+ */
+function renderProjectManifest(prepared, artifacts, manifestPath, spans) {
+    const inputPaths = new Set(prepared.assets.map(({ fullPath }) => fullPath));
+    const semanticArtifacts = artifacts.filter(artifact => artifact.provenance.kind == "text");
+    return stringifyCanonicalJson({
+        configuration: prepared.configuration,
+        generator: { name: "semantifold", version: generatorVersion },
+        ownership: {
+            excludedPathPatterns,
+            ownedPaths: [...artifacts.map(({ path }) => path), manifestPath],
+            ownedRoot: projectRoot,
+            sha256: artifacts.map(artifact => ({ path: artifact.path, sha256: hashContent(artifact.content) }))
+        },
+        platforms: {
+            android: { acceptance: "tensorbuzz-kvm", artifacts: "generated" },
+            ios: {
+                acceptance: "deferred",
+                artifacts: "omitted",
+                reason: "Owner direction defers macOS, Xcode, Apple SDK, signing, and iOS Simulator qualification."
+            }
+        },
+        provenance: {
+            configuration: Object.keys(prepared.configuration).sort().map(fieldName => ({
+                field: fieldName,
+                manifestPointer: `/configuration/${fieldName}`,
+                outputs: configurationOutputs(spans, fieldName)
+            })),
+            inputs: prepared.assets.map(asset => ({
+                contentKind: asset.contentKind,
+                mediaType: asset.mediaType,
+                path: asset.fullPath,
+                sha256: asset.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: "SemantifoldFlutterProject",
+        semanticProgram: semanticProgramManifest(prepared),
+        target: "flutter",
+        toolchain: { android: androidToolchain, flutter: flutterToolchain },
+        version: 1
+    });
+}
+/**
+ * Describes the complete semantic program inside the application manifest.
+ * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.
+ * @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 Flutter 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: {
+            generatedArtifact: prepared.modulePaths.get(entryId),
+            generatedFunctionIdentity: `SemantifoldModule${moduleName(entryId)}.semantifoldEntry`,
+            moduleId: entryId,
+            widgetArtifact: `${projectRoot}/lib/main.dart`
+        },
+        modules,
+        schema: "SemantifoldFlutterSemanticProgram",
+        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
+    };
+}
+/**
+ * Normalizes and validates the closed application configuration.
+ * @param {unknown} candidate - Candidate configuration.
+ * @returns {import("../semantic/types.js").FlutterApplicationConfiguration} Normalized configuration.
+ */
+function normalizeConfiguration(candidate) {
+    if (candidate === undefined)
+        candidate = {};
+    if (!isPlainObject(candidate) || Object.keys(candidate).some(key => !configurationFields.has(key))) {
+        invalidConfiguration("Flutter application configuration must be a closed plain object.");
+    }
+    const configuration = /** @type {import("../semantic/types.js").FlutterApplicationConfigurationInput} */ (candidate);
+    const packageName = configuration.packageName ?? "semantifold_generated";
+    const organization = configuration.organization ?? "dev.semantifold";
+    const applicationId = configuration.applicationId ?? `${organization}.generated`;
+    const activityClassName = configuration.activityClassName ?? "MainActivity";
+    const displayName = configuration.displayName ?? "Semantifold";
+    const minimumSdk = configuration.minimumSdk ?? 23;
+    const targetSdk = configuration.targetSdk ?? 35;
+    const compileSdk = configuration.compileSdk ?? 35;
+    const buildToolsVersion = configuration.buildToolsVersion ?? "35.0.0";
+    const versionCode = configuration.versionCode ?? 1;
+    const versionName = configuration.versionName ?? "1.0.0";
+    if (typeof packageName != "string" || !/^[a-z][a-z0-9_]*$/u.test(packageName) || dartKeywords.has(packageName) ||
+        forbiddenPackageNames.has(packageName))
+        invalidConfiguration("Dart package name must be a non-reserved lowercase underscore identifier.");
+    if (typeof organization != "string" || !isReverseDns(organization, 2)) {
+        invalidConfiguration("Organization must be a lowercase reverse-DNS identity with at least two segments.");
+    }
+    if (typeof applicationId != "string" || !isReverseDns(applicationId, 3) || !applicationId.startsWith(`${organization}.`)) {
+        invalidConfiguration("Application ID must extend the exact organization as lowercase reverse DNS.");
+    }
+    if (typeof activityClassName != "string" || !/^[A-Z][A-Za-z0-9]*$/u.test(activityClassName) ||
+        javaKeywords.has(activityClassName))
+        invalidConfiguration("Activity class name must be an ASCII upper-camel Java identifier.");
+    if (androidRunnerBaseClassNames.has(activityClassName)) {
+        invalidConfiguration("Activity class name must not collide with the imported Flutter launcher base class.");
+    }
+    if (typeof displayName != "string" || displayName.length == 0 || displayName.trim() != displayName ||
+        [...displayName].length > 64 || !hasOnlyUnicodeScalars(displayName) || /[\p{Cc}\p{Zl}\p{Zp}\uFFFE\uFFFF]/u.test(displayName)) {
+        invalidConfiguration("Display name must be a non-empty single-line Unicode scalar string of at most 64 characters.");
+    }
+    if (minimumSdk !== 23 || targetSdk !== 35 || compileSdk !== 35) {
+        invalidConfiguration("SDK levels must reuse the qualified minimum 23, target 35, and compile 35 Android matrix.");
+    }
+    if (buildToolsVersion != "35.0.0")
+        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) || versionName.includes("+")) {
+        invalidConfiguration("Version name must be a canonical semantic version without build metadata.");
+    }
+    if (configuration.permissions !== undefined &&
+        (!isDenseArray(configuration.permissions) || configuration.permissions.length != 0)) {
+        invalidConfiguration("The baseline Flutter permission set must be empty.");
+    }
+    return { activityClassName, applicationId, buildToolsVersion, compileSdk, displayName, minimumSdk, organization,
+        packageName, targetSdk, versionCode, versionName };
+}
+/**
+ * Snapshots and validates exact caller assets.
+ * @param {unknown} candidate - Candidate asset collection.
+ * @returns {FlutterAsset[]} Normalized assets.
+ */
+function normalizeAssets(candidate) {
+    if (candidate === undefined)
+        return [];
+    if (!isDenseArray(candidate))
+        invalidAsset("Flutter assets must be a dense array.");
+    /** @type {FlutterAsset[]} */
+    const assets = [];
+    for (let index = 0; index < candidate.length; index += 1) {
+        const item = candidate[index];
+        if (!isPlainObject(item) || Object.keys(item).length != assetFields.size ||
+            Object.keys(item).some(key => !assetFields.has(key)))
+            invalidAsset(`Asset ${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) || !String(path).startsWith("assets/")) {
+            invalidAsset(`Asset ${index} requires a safe portable path below 'assets'.`);
+        }
+        if (typeof content != "string" && !(content instanceof Uint8Array) || typeof content == "string" &&
+            (content.length == 0 || !hasOnlyUnicodeScalars(content)) || content instanceof Uint8Array && content.byteLength == 0) {
+            invalidAsset(`Asset '${path}' requires non-empty exact content.`);
+        }
+        if (typeof mediaType != "string" || !mediaTypePattern.test(mediaType) || /[\r\n]/u.test(mediaType)) {
+            invalidAsset(`Asset '${path}' requires an explicit valid 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) {
+            invalidAsset(`Asset '${path}' SHA-256 does not match its exact content.`);
+        }
+        assets.push({ content: snapshot, contentKind: typeof snapshot == "string" ? "text" : "binary",
+            fullPath: `${projectRoot}/${path}`, mediaType, path, sha256 });
+    }
+    assets.sort((left, right) => left.fullPath < right.fullPath ? -1 : left.fullPath > right.fullPath ? 1 : 0);
+    const conflict = findPortableArtifactPathConflict(assets.map(({ fullPath }) => fullPath));
+    if (conflict)
+        invalidAsset(`Asset path '${conflict.path}' has a ${conflict.kind} conflict.`);
+    return assets;
+}
+/**
+ * Enumerates every generator-owned application path.
+ * @param {import("../semantic/types.js").FlutterApplicationConfiguration} configuration - Normalized configuration.
+ * @param {Map<string, string>} modulePaths - Semantic module paths.
+ * @returns {string[]} Complete paths.
+ */
+function applicationPaths(configuration, modulePaths) {
+    const packagePath = configuration.applicationId.replaceAll(".", "/");
+    return [
+        `${projectRoot}/.metadata`,
+        `${projectRoot}/analysis_options.yaml`,
+        `${projectRoot}/android/app/build.gradle.kts`,
+        `${projectRoot}/android/app/src/main/AndroidManifest.xml`,
+        `${projectRoot}/android/app/src/main/java/${packagePath}/${configuration.activityClassName}.java`,
+        `${projectRoot}/android/app/src/main/res/drawable/launch_background.xml`,
+        `${projectRoot}/android/app/src/main/res/values-night/styles.xml`,
+        `${projectRoot}/android/app/src/main/res/values/styles.xml`,
+        `${projectRoot}/android/app/src/main/res/xml/backup_rules.xml`,
+        `${projectRoot}/android/app/src/main/res/xml/data_extraction_rules.xml`,
+        `${projectRoot}/android/build.gradle.kts`,
+        `${projectRoot}/android/gradle.properties`,
+        `${projectRoot}/android/settings.gradle.kts`,
+        `${projectRoot}/lib/main.dart`,
+        ...modulePaths.values(),
+        `${projectRoot}/lib/src/semantic/semantifold.dart`,
+        `${projectRoot}/pubspec.lock`,
+        `${projectRoot}/pubspec.yaml`,
+        `${projectRoot}/test/semantic_logic_test.dart`,
+        `${projectRoot}/test/widget_test.dart`,
+        `${projectRoot}/semantifold-project.json`
+    ];
+}
+/**
+ * Converts one normalized asset to an owned artifact.
+ * @param {FlutterAsset} asset - Normalized asset.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Generated asset.
+ */
+function assetArtifact(asset) {
+    const reason = `Exact caller-provided Flutter asset (sha256:${asset.sha256}).`;
+    if (typeof asset.content == "string")
+        return { ...syntheticText(asset.fullPath, "resource", asset.content, reason), mediaType: asset.mediaType };
+    const content = new Uint8Array(asset.content);
+    return {
+        content,
+        contentKind: "binary",
+        mediaType: asset.mediaType,
+        ownership: "generated",
+        path: asset.fullPath,
+        provenance: { kind: "bytes", mapping: createByteMapping({
+                byteLength: content.byteLength,
+                path: asset.fullPath,
+                ranges: [{ generated: { end: content.byteLength, start: 0 },
+                        origin: { kind: "synthetic", reason, relatedOrigins: [] }, role: "asset" }]
+            }) },
+        role: "resource"
+    };
+}
+/**
+ * Creates a synthetic text artifact.
+ * @param {string} path - Artifact path.
+ * @param {import("../semantic/types.js").GeneratedArtifactRole} role - Artifact role.
+ * @param {string} content - Exact content.
+ * @param {string} reason - Synthetic provenance reason.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Generated artifact.
+ */
+function syntheticText(path, role, content, reason) {
+    return { content, contentKind: "text", mediaType: mediaTypeFor(path), ownership: "generated", path,
+        provenance: { kind: "synthetic", reason, relatedOrigins: [] }, role };
+}
+/**
+ * Creates text whose configuration spans are recorded separately.
+ * @param {string} path - Artifact path.
+ * @param {import("../semantic/types.js").GeneratedArtifactRole} role - Artifact role.
+ * @param {string} content - Exact content.
+ * @param {string} reason - Synthetic provenance reason.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Generated artifact.
+ */
+function configuredText(path, role, content, reason) {
+    return syntheticText(path, role, content, reason);
+}
+/**
+ * Selects an exact media type from an owned path.
+ * @param {string} path - Artifact path.
+ * @returns {string} Media type.
+ */
+function mediaTypeFor(path) {
+    if (path.endsWith(".dart"))
+        return "text/x-dart";
+    if (path.endsWith(".json"))
+        return "application/json";
+    if (path.endsWith(".yaml") || path.endsWith(".lock"))
+        return "application/yaml";
+    if (path.endsWith(".xml"))
+        return "application/xml";
+    if (path.endsWith(".java"))
+        return "text/x-java-source";
+    if (path.endsWith(".kts"))
+        return "text/x-kotlin";
+    return "text/plain";
+}
+/**
+ * Marks one rendered value as configuration-derived.
+ * @param {string} fieldName - Configuration field.
+ * @param {string} value - Rendered value.
+ * @returns {{field: string, value: string}} Marked value.
+ */
+function field(fieldName, value) {
+    return { field: fieldName, value };
+}
+/**
+ * Joins configured parts while recording exact output spans.
+ * @param {string} path - Artifact path.
+ * @param {ConfigurationSpan[]} spans - Configuration provenance sink.
+ * @param {(string | {field: string, value: string})[]} parts - Literal and configured parts.
+ * @returns {string} Rendered content.
+ */
+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 exact generated ranges for one configuration field.
+ * @param {ConfigurationSpan[]} spans - Recorded spans.
+ * @param {string} fieldName - Configuration field.
+ * @returns {{path: string, ranges: {end: number, start: number}[]}[]} Grouped 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 }));
+}
+/**
+ * Checks whether provenance refers to one source file.
+ * @param {import("../semantic/types.js").SemanticOrigin} origin - Semantic origin.
+ * @param {string} filename - Source filename.
+ * @returns {boolean} Whether the origin references the source.
+ */
+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 artifact content.
+ * @param {string | Uint8Array} content - Artifact content.
+ * @returns {string} Lowercase SHA-256.
+ */
+function hashContent(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+/**
+ * Serializes a recursively sorted JSON value.
+ * @param {unknown} value - JSON-compatible value.
+ * @returns {string} Canonical indented JSON.
+ */
+function stringifyCanonicalJson(value) {
+    return `${JSON.stringify(sortJson(value), null, 2)}\n`;
+}
+/**
+ * Recursively sorts object keys without reordering arrays.
+ * @param {unknown} value - JSON-compatible value.
+ * @returns {unknown} Sorted 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])]));
+}
+/**
+ * Validates a lowercase reverse-DNS identity.
+ * @param {string} value - Candidate identity.
+ * @param {number} segments - Required minimum segment count.
+ * @returns {boolean} Whether the identity is valid.
+ */
+function isReverseDns(value, segments) {
+    const parts = value.split(".");
+    return parts.length >= segments && parts.every(part => /^[a-z][a-z0-9_]*$/u.test(part) && !javaKeywords.has(part));
+}
+/**
+ * Derives one stable Dart class suffix.
+ * @param {string} id - Semantic module identity.
+ * @returns {string} Dart class suffix.
+ */
+function moduleName(id) {
+    return id.split(/[._-]+/u).map(part => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
+}
+/**
+ * Derives one stable semantic part filename.
+ * @param {string} id - Semantic module identity.
+ * @returns {string} Dart filename.
+ */
+function moduleFileName(id) {
+    return id.replaceAll(/[.-]/gu, "_");
+}
+/**
+ * Allocates a collision-free private output sink binding.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @returns {string} Dart binding name.
+ */
+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 every block-owned binding name.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {Set<string>} bindings - Mutable name set.
+ * @returns {void}
+ */
+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);
+        }
+    }
+}
+/**
+ * Wraps one module in an explicit semantic project.
+ * @param {import("../semantic/types.js").SemanticModule | undefined} candidate - Candidate module.
+ * @returns {import("../semantic/types.js").SemanticProgram} Normalized project.
+ */
+function normalizeSingleModule(candidate) {
+    if (!isPlainObject(candidate))
+        unsupportedCapability("flutter", "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("flutter", "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) };
+}
+/**
+ * Converts one module declaration to an explicit application export.
+ * @param {{id?: string, location: import("../semantic/types.js").SourceLocation, name: string}} declaration - 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: "Export", location: declaration.location, symbolKind };
+}
+/**
+ * Re-keys one standalone module for application-project ownership.
+ * @param {import("../semantic/types.js").SemanticModule} module - Standalone module.
+ * @param {string} moduleId - Stable application module identity.
+ * @returns {void}
+ */
+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 semantic declaration identities recursively.
+     * @param {unknown} value - Candidate semantic value.
+     * @returns {void}
+     */
+    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 an XML attribute value.
+ * @param {string} value - Raw value.
+ * @returns {string} Escaped value.
+ */
+function xmlEscape(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+/**
+ * Escapes a single-quoted Dart literal body.
+ * @param {string} value - Raw value.
+ * @returns {string} Escaped value.
+ */
+function dartEscape(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("$", "\\$");
+}
+/**
+ * Checks for a plain string-keyed object.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is plain.
+ */
+function isPlainObject(value) {
+    return Boolean(value) && typeof value == "object" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Throws a stable invalid-input diagnostic.
+ * @param {string} message - Diagnostic detail.
+ * @returns {never} Never returns.
+ */
+function invalidInput(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_INPUT", language: "flutter", message });
+}
+/**
+ * Throws a stable invalid-configuration diagnostic.
+ * @param {string} message - Diagnostic detail.
+ * @returns {never} Never returns.
+ */
+function invalidConfiguration(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_CONFIGURATION", language: "flutter", message });
+}
+/**
+ * Throws a stable invalid-asset diagnostic.
+ * @param {string} message - Diagnostic detail.
+ * @returns {never} Never returns.
+ */
+function invalidAsset(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_ASSET", language: "flutter", message });
+}
+/**
+ * Throws a stable invalid-path diagnostic.
+ * @param {string} message - Diagnostic detail.
+ * @returns {never} Never returns.
+ */
+function invalidPath(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_PATH", language: "flutter", message });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flutter.js","sourceRoot":"","sources":["../../../src/backends/flutter.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 {dartRuntime} from \"./dart-runtime.js\"\nimport {emitDartBlock, findUnreadDartLocals} from \"./dart.js\"\nimport {preflightSemanticProgram} from \"./program.js\"\nimport {emitScalarType} from \"./scalars.js\"\nimport {SourceWriter} from \"./writer.js\"\n\nconst projectRoot = \"generated/flutter-app\"\nconst generatorVersion = \"0.6.0\"\nconst flutterToolchain = Object.freeze({\n  archive: \"flutter_linux_3.47.4-stable.tar.xz\",\n  archiveSha256: \"5b45f0ceda99b9bebdc873e7e69f6450aeb4c30f454b505e2e62fc9255a907d3\",\n  dart: \"3.13.3\",\n  revision: \"9584c6713b324636289d067944a46fd6b49df14b\",\n  version: \"3.47.4\"\n})\nconst androidToolchain = Object.freeze({\n  androidGradlePlugin: \"8.11.1\",\n  buildTools: \"35.0.0\",\n  cmake: \"3.22.1\",\n  compileSdk: 35,\n  gradle: \"8.14\",\n  java: \"21.0.8\",\n  kotlinGradlePlugin: \"2.2.20\",\n  minimumSdk: 23,\n  ndk: \"27.0.12077973\",\n  targetSdk: 35\n})\n/** @type {readonly (readonly [string, string, string])[]} */\nconst flutterLockedHostedPackages = Object.freeze([\n  [\"async\", \"2.13.1\", \"e2eb0491ba5ddb6177742d2da23904574082139b07c1e33b8503b9f46f3e1a37\"],\n  [\"boolean_selector\", \"2.1.2\", \"8aab1771e1243a5063b8b0ff68042d67334e3feab9e95b9490f9a6ebf73b42ea\"],\n  [\"characters\", \"1.4.1\", \"faf38497bda5ead2a8c7615f4f7939df04333478bf32e4173fcb06d428b5716b\"],\n  [\"clock\", \"1.1.3\", \"e51d50bca3217c9a9fa2b41a30e4a38971133f5f9ec7a3d57bae095007f1d28e\"],\n  [\"collection\", \"1.19.1\", \"2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76\"],\n  [\"fake_async\", \"1.3.3\", \"5368f224a74523e8d2e7399ea1638b37aecfca824a3cc4dfdf77bf1fa905ac44\"],\n  [\"leak_tracker\", \"11.0.2\", \"33e2e26bdd85a0112ec15400c8cbffea70d0f9c3407491f672a2fad47915e2de\"],\n  [\"leak_tracker_flutter_testing\", \"3.0.10\", \"1dbc140bb5a23c75ea9c4811222756104fbcd1a27173f0c34ca01e16bea473c1\"],\n  [\"leak_tracker_testing\", \"3.0.2\", \"8d5a2d49f4a66b49744b23b018848400d23e54caf9463f4eb20df3eb8acb2eb1\"],\n  [\"matcher\", \"0.12.20\", \"31bd099b47c10cd1aeb55146a2d46ce0277630ecef3f7dae54ad7873f36696cd\"],\n  [\"material_color_utilities\", \"0.13.0\", \"9c337007e82b1889149c82ed242ed1cb24a66044e30979c44912381e9be4c48b\"],\n  [\"meta\", \"1.19.0\", \"307249ce4ff29d58a18e97f6345f539382eb9c9c29ecda628900f31de0443dd9\"],\n  [\"path\", \"1.9.1\", \"75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5\"],\n  [\"source_span\", \"1.10.2\", \"56a02f1f4cd1a2d96303c0144c93bd6d909eea6bee6bf5a0e0b685edbd4c47ab\"],\n  [\"stack_trace\", \"1.12.2\", \"277654b3034d17ac6f9f1cb5595db011b1d5d41e8806866db28e0abaa101c490\"],\n  [\"stream_channel\", \"2.1.4\", \"969e04c80b8bcdf826f8f16579c7b14d780458bd97f56d107d3950fdbeef059d\"],\n  [\"string_scanner\", \"1.4.1\", \"921cd31725b72fe181906c6a94d987c78e3b98c2e205b397ea399d4054872b43\"],\n  [\"term_glyph\", \"1.2.2\", \"7f554798625ea768a7518313e58f83891c7f5024f88e46e7182a4558850a4b8e\"],\n  [\"test_api\", \"0.7.12\", \"2a122cbe059f8b610d3a5415f42e255b6c17b1f21eee1d960f31080237fb4f11\"],\n  [\"vector_math\", \"2.4.2\", \"f36f9f3be64c6198714492bb455c11056e33e2f85d9a0b676a48301e44fdcf47\"],\n  [\"vm_service\", \"15.3.0\", \"5f37239c4851efcef929cea7824e76df7f2f0970aef85d66bbc430afa40e72f0\"]\n])\n/** @type {readonly (readonly [string, \"direct main\" | \"direct dev\" | \"transitive\"])[]} */\nconst flutterLockedSdkPackages = Object.freeze([\n  [\"flutter\", \"direct main\"],\n  [\"flutter_test\", \"direct dev\"],\n  [\"sky_engine\", \"transitive\"]\n])\n/** @type {Readonly<Set<import(\"../semantic/types.js\").SemanticLanguage>>} */\nconst flutterSourceLanguages = new Set([\n  \"php\", \"ruby\", \"javascript\", \"typescript\", \"java\", \"kotlin\", \"python\", \"csharp\", \"go\", \"c\", \"cpp\", \"rust\", \"swift\", \"dart\", \"zig\"\n])\nconst requestFields = new Set([\"assets\", \"configuration\", \"language\", \"module\", \"program\", \"role\"])\nconst configurationFields = new Set([\n  \"activityClassName\", \"applicationId\", \"buildToolsVersion\", \"compileSdk\", \"displayName\", \"minimumSdk\", \"organization\",\n  \"packageName\", \"permissions\", \"targetSdk\", \"versionCode\", \"versionName\"\n])\nconst assetFields = new Set([\"content\", \"mediaType\", \"path\", \"sha256\"])\nconst dartKeywords = new Set([\n  \"abstract\", \"as\", \"assert\", \"async\", \"await\", \"base\", \"break\", \"case\", \"catch\", \"class\", \"const\", \"continue\",\n  \"covariant\", \"default\", \"deferred\", \"do\", \"dynamic\", \"else\", \"enum\", \"export\", \"extends\", \"extension\", \"external\",\n  \"factory\", \"false\", \"final\", \"finally\", \"for\", \"Function\", \"get\", \"hide\", \"if\", \"implements\", \"import\", \"in\",\n  \"interface\", \"is\", \"late\", \"library\", \"mixin\", \"new\", \"null\", \"of\", \"on\", \"operator\", \"part\", \"required\",\n  \"rethrow\", \"return\", \"sealed\", \"set\", \"show\", \"static\", \"super\", \"switch\", \"sync\", \"this\", \"throw\", \"true\",\n  \"try\", \"typedef\", \"var\", \"void\", \"when\", \"while\", \"with\", \"yield\"\n])\nconst javaKeywords = new Set([\n  \"abstract\", \"assert\", \"boolean\", \"break\", \"byte\", \"case\", \"catch\", \"char\", \"class\", \"const\", \"continue\", \"default\",\n  \"do\", \"double\", \"else\", \"enum\", \"extends\", \"final\", \"finally\", \"float\", \"for\", \"goto\", \"if\", \"implements\",\n  \"import\", \"instanceof\", \"int\", \"interface\", \"long\", \"native\", \"new\", \"package\", \"private\", \"protected\", \"public\",\n  \"return\", \"short\", \"static\", \"strictfp\", \"super\", \"switch\", \"synchronized\", \"this\", \"throw\", \"throws\", \"transient\",\n  \"try\", \"void\", \"volatile\", \"while\"\n])\nconst forbiddenPackageNames = new Set([\n  ...flutterLockedHostedPackages.map(([name]) => name),\n  ...flutterLockedSdkPackages.map(([name]) => name),\n  \"integration_test\",\n  \"semantifold\"\n])\nconst androidRunnerBaseClassNames = new Set([\"FlutterActivity\"])\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 mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\\/[A-Za-z0-9!#$&^_.+-]+(?:[\\u0020-\\u007e]+)?$/u\nconst excludedPathPatterns = Object.freeze([\n  \".dart_tool/**\", \".flutter-plugins\", \".flutter-plugins-dependencies\", \"android/.gradle/**\", \"android/app/build/**\",\n  \"android/local.properties\", \"build/**\"\n])\nconst outputSinkRuntime = `\nfinal class _SemantifoldOutputSink {\n  final List<String> _values = <String>[];\n\n  void write(Object value) {\n    if (value is! int && value is! bool && value is! String) {\n      throw StateError('Unsupported Semantifold output value');\n    }\n    _values.add(value.toString());\n  }\n\n  List<String> snapshot() => List<String>.unmodifiable(_values);\n}\n`\n\n/** @typedef {{content: string | Uint8Array, contentKind: \"binary\" | \"text\", fullPath: string, mediaType: string, path: string, sha256: string}} FlutterAsset */\n/** @typedef {{end: number, field: string, path: string, start: number}} ConfigurationSpan */\n\n/**\n * Preflights a complete Flutter application request before rendering any artifact.\n * @param {Record<string, unknown>} input - Candidate application request.\n * @returns {{assets: FlutterAsset[], configuration: import(\"../semantic/types.js\").FlutterApplicationConfiguration, modulePaths: Map<string, string>, modules: import(\"../semantic/types.js\").SemanticModule[], packagePath: string, program: import(\"../semantic/types.js\").SemanticProgram, sources: {content: string, filename: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} Prepared application.\n */\nexport function preflightFlutterApplication(input) {\n  if (!isPlainObject(input) || Object.keys(input).some(key => !requestFields.has(key)) ||\n    Boolean(input.module) == Boolean(input.program)) {\n    invalidInput(\"Flutter application generation requires a closed request with exactly one semantic module or program.\")\n  }\n  if (input.language !== undefined && input.language != \"flutter\" || input.role !== undefined && input.role != \"application\") {\n    invalidInput(\"Flutter application generation accepts only the Flutter 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: \"dart\",\n    diagnosticLanguage: \"flutter\",\n    program: /** @type {import(\"../semantic/types.js\").SemanticProgram} */ (program),\n    sourceLanguages: flutterSourceLanguages\n  })\n  const entryModule = prepared.modules.find(module => Reflect.get(module, \"id\") == prepared.program.entryModule)\n  const entryCollision = entryModule?.functions.find(({name}) => name == \"semantifoldEntry\")\n\n  if (entryCollision) unsupportedCapability(\"flutter\", \"reserved generated semantic entry function 'semantifoldEntry'\", entryCollision.location)\n  const packagePath = configuration.applicationId.replaceAll(\".\", \"/\")\n  const modulePaths = new Map(prepared.modules.map(module => {\n    const moduleId = /** @type {string} */ (Reflect.get(module, \"id\"))\n\n    return [moduleId, `${projectRoot}/lib/src/semantic/${moduleFileName(moduleId)}.dart`]\n  }))\n  const assets = normalizeAssets(input.assets)\n  const completePaths = [...applicationPaths(configuration, modulePaths), ...assets.map(({fullPath}) => fullPath)]\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  const semanticNames = new Map()\n\n  for (const module of prepared.modules) {\n    const moduleId = /** @type {string} */ (Reflect.get(module, \"id\"))\n    const name = moduleName(moduleId)\n    const previous = semanticNames.get(name)\n\n    if (previous) invalidPath(`Semantic modules '${previous}' and '${moduleId}' collide at generated Dart class '${name}'.`)\n    semanticNames.set(name, moduleId)\n  }\n\n  return {...prepared, assets, configuration, modulePaths, packagePath}\n}\n\n/**\n * Generates one deterministic SDK-only Flutter project for the qualified Android lane.\n * @param {Record<string, unknown>} input - Application generation request.\n * @returns {{artifacts: import(\"../semantic/types.js\").GeneratedSetArtifact[], metadata: {applicationManifest: string, platformQualification: {android: string, ios: string}}, target: \"flutter\"}} Candidate artifact set.\n */\nexport function generateFlutterApplication(input) {\n  const prepared = preflightFlutterApplication(input)\n  const configurationSpans = /** @type {ConfigurationSpan[]} */ ([])\n  const configuration = prepared.configuration\n  const semanticArtifacts = renderSemanticArtifacts(prepared)\n  const artifacts = /** @type {import(\"../semantic/types.js\").GeneratedSetArtifact[]} */ ([\n    syntheticText(`${projectRoot}/.metadata`, \"manifest\", renderMetadata(),\n      \"Exact Flutter 3.47.4 project-template identity; generated migration is disabled.\"),\n    syntheticText(`${projectRoot}/analysis_options.yaml`, \"support\", renderAnalysisOptions(),\n      \"Closed analyzer configuration without external lint packages.\"),\n    configuredText(`${projectRoot}/android/app/build.gradle.kts`, \"manifest\", renderAndroidAppBuild(configuration, configurationSpans),\n      \"Task 028-compatible Android build and isolated debug-signing configuration.\"),\n    configuredText(`${projectRoot}/android/app/src/main/AndroidManifest.xml`, \"manifest\",\n      renderAndroidManifest(configuration, configurationSpans), \"Closed permission-free Flutter Android application manifest.\"),\n    configuredText(`${projectRoot}/android/app/src/main/java/${prepared.packagePath}/${configuration.activityClassName}.java`, \"support\",\n      renderAndroidActivity(configuration, configurationSpans), \"Synthetic Flutter Android embedding launcher.\"),\n    syntheticText(`${projectRoot}/android/app/src/main/res/drawable/launch_background.xml`, \"resource\", renderLaunchBackground(),\n      \"Synthetic minimum-SDK-qualified Flutter launch background.\"),\n    syntheticText(`${projectRoot}/android/app/src/main/res/values-night/styles.xml`, \"resource\", renderAndroidStyles(true),\n      \"Synthetic dark platform launch and Flutter host themes.\"),\n    syntheticText(`${projectRoot}/android/app/src/main/res/values/styles.xml`, \"resource\", renderAndroidStyles(false),\n      \"Synthetic light platform launch and Flutter host themes.\"),\n    syntheticText(`${projectRoot}/android/app/src/main/res/xml/backup_rules.xml`, \"resource\", renderBackupRules(),\n      \"Closed API 23-30 full-backup exclusions reused from the Android safety contract.\"),\n    syntheticText(`${projectRoot}/android/app/src/main/res/xml/data_extraction_rules.xml`, \"resource\", renderDataExtractionRules(),\n      \"Closed Android 12+ backup and transfer exclusions reused from the Android safety contract.\"),\n    syntheticText(`${projectRoot}/android/build.gradle.kts`, \"manifest\", renderAndroidRootBuild(),\n      \"Task 028-compatible deterministic Android root build.\"),\n    syntheticText(`${projectRoot}/android/gradle.properties`, \"support\", renderAndroidGradleProperties(),\n      \"Pinned isolated Gradle properties for the qualified Android lane.\"),\n    configuredText(`${projectRoot}/android/settings.gradle.kts`, \"manifest\", renderAndroidSettings(configuration, configurationSpans),\n      \"Exact Flutter Gradle plugin loader with the pinned Task 028 Android plugin matrix.\"),\n    configuredText(`${projectRoot}/lib/main.dart`, \"entry\", renderWidgetApplication(prepared, configurationSpans),\n      \"Synthetic stateless Material application and labelled output widget.\"),\n    ...semanticArtifacts,\n    syntheticText(`${projectRoot}/pubspec.lock`, \"manifest\", renderPubspecLock(),\n      \"Exact Flutter 3.47.4 SDK dependency resolution; no caller package resolution.\"),\n    configuredText(`${projectRoot}/pubspec.yaml`, \"manifest\", renderPubspec(prepared, configurationSpans),\n      \"Closed SDK-only Flutter package and asset manifest.\"),\n    configuredText(`${projectRoot}/test/semantic_logic_test.dart`, \"support\", renderLogicTest(prepared, configurationSpans),\n      \"SDK-owned Flutter test for fresh deterministic semantic entry execution.\"),\n    configuredText(`${projectRoot}/test/widget_test.dart`, \"support\", renderWidgetTest(prepared, configurationSpans),\n      \"SDK-owned Flutter widget test for exact text, key, and semantics label.\"),\n    ...prepared.assets.map(assetArtifact)\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 Flutter project ownership, toolchain, provenance, and platform-status manifest.\"))\n\n  return {\n    artifacts,\n    metadata: {\n      applicationManifest: manifestPath,\n      platformQualification: {android: \"tensorbuzz-kvm\", ios: \"deferred-owner-direction\"}\n    },\n    target: \"flutter\"\n  }\n}\n\n/**\n * Emits mapped application-owned Dart semantic modules.\n * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared application.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact[]} Semantic Dart artifacts.\n */\nfunction renderSemanticArtifacts(prepared) {\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  /** @type {import(\"../semantic/types.js\").GeneratedSetArtifact[]} */\n  const artifacts = [syntheticText(`${projectRoot}/lib/src/semantic/semantifold.dart`, \"support\",\n    renderSemanticLibrary(prepared), \"Shared checked Dart scalar/output runtime and deterministic part ownership.\")]\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 Flutter function '${expression.resolution?.declarationId}'.`)\n\n        return `SemantifoldModule${moduleName(resolved.moduleId)}.${resolved.declaration.name}`\n      },\n      filename,\n      language: \"dart\",\n      module,\n      program: prepared.program,\n      programPaths: prepared.modulePaths,\n      sources: prepared.sources\n    })\n\n    writer.synthetic(\"part of 'semantifold.dart';\\n\\n\", \"Flutter semantic library part directive\", [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-dart\",\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 Dart part.\n * @param {SourceWriter} writer - Mapped source writer.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Prepared semantic module.\n * @param {string} moduleId - Stable semantic module identity.\n * @param {boolean} entry - Whether this module owns the application entry.\n * @param {string} sinkName - Collision-safe output sink binding.\n */\nfunction emitSemanticModule(writer, module, moduleId, entry, sinkName) {\n  const unreadLocals = findUnreadDartLocals(module)\n\n  writer.synthetic(`abstract final class SemantifoldModule${moduleName(moduleId)} {\\n`,\n    \"Flutter semantic module namespace\", [module], [\"\"])\n  module.functions.forEach((declaration, functionIndex) => {\n    const path = `/functions/${functionIndex}`\n\n    writer.synthetic(\"  static \", \"Flutter namespaced function scaffold\", [declaration], [path])\n    writer.mapped(emitScalarType(\"dart\", declaration.returnType), {\n      mappingKind: \"exact\", node: declaration.returnType, path: `${path}/returnType`, role: \"type\"\n    })\n    writer.synthetic(\" \", \"declaration spacing\", [declaration], [path])\n    writer.mapped(declaration.name, {mappingKind: \"exact\", node: declaration, path, role: \"name\"})\n    const parameterTexts = declaration.parameters.map(parameter => `${emitScalarType(\"dart\", parameter.type)} ${parameter.name}`)\n\n    parameterTexts.push(`_SemantifoldOutputSink ${sinkName}`)\n    const multiline = writer.column - 1 + `(${parameterTexts.join(\", \")}) {`.length > 80\n\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: declaration, path})\n    declaration.parameters.forEach((parameter, parameterIndex) => {\n      const parameterPath = `${path}/parameters/${parameterIndex}`\n\n      if (multiline) writer.synthetic(`${parameterIndex ? \"\" : \"\\n\"}    `,\n        \"Dart application parameter indentation\", [parameter], [parameterPath])\n      else if (parameterIndex) writer.synthetic(\", \", \"parameter separator\", [parameter], [parameterPath])\n      writer.mapped(emitScalarType(\"dart\", parameter.type), {\n        mappingKind: \"exact\", node: parameter.type, path: `${parameterPath}/type`, role: \"type\"\n      })\n      writer.synthetic(\" \", \"parameter spacing\", [parameter], [parameterPath])\n      writer.mapped(parameter.name, {mappingKind: \"exact\", node: parameter, path: parameterPath, role: \"name\"})\n      if (multiline) writer.synthetic(\",\\n\", \"Dart formatter parameter separator\", [parameter], [parameterPath])\n    })\n    if (multiline) writer.synthetic(`${declaration.parameters.length ? \"\" : \"\\n\"}    _SemantifoldOutputSink ${sinkName},\\n  `,\n      \"Flutter output sink parameter\", [declaration], [path])\n    else writer.synthetic(`${declaration.parameters.length ? \", \" : \"\"}_SemantifoldOutputSink ${sinkName}`,\n      \"Flutter output sink parameter\", [declaration], [path])\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: declaration, path})\n    writer.synthetic(\" {\\n\", \"Dart function body scaffold\", [declaration], [path])\n    emitDartBlock(writer, declaration.body, \"    \", `${path}/body`, unreadLocals, `${sinkName}.write`, true)\n    writer.synthetic(\"  }\\n\", \"Dart function body scaffold\", [declaration], [path])\n    if (functionIndex + 1 < module.functions.length || entry) {\n      writer.synthetic(\"\\n\", \"Dart formatter declaration separator\", [declaration], [path])\n    }\n  })\n  if (entry) {\n    writer.synthetic(\"  static List<String> semantifoldEntry() {\\n\", \"Flutter semantic entry scaffold\",\n      [module.entryPoint], [\"/entryPoint\"])\n    writer.synthetic(`    final _SemantifoldOutputSink ${sinkName} = _SemantifoldOutputSink();\\n`,\n      \"Flutter output sink allocation\", [module.entryPoint], [\"/entryPoint\"])\n    emitDartBlock(writer, module.entryPoint.body, \"    \", \"/entryPoint/body\", unreadLocals, `${sinkName}.write`, true)\n    writer.synthetic(`    return ${sinkName}.snapshot();\\n`, \"Flutter semantic output return\",\n      [module.entryPoint], [\"/entryPoint\"])\n    writer.synthetic(\"  }\\n\", \"Flutter semantic entry scaffold\", [module.entryPoint], [\"/entryPoint\"])\n  }\n  writer.synthetic(\"}\\n\", \"Flutter semantic module namespace\", [module], [\"\"])\n}\n\n/**\n * Renders the shared semantic Dart library.\n * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.\n * @returns {string} Dart library source.\n */\nfunction renderSemanticLibrary(prepared) {\n  const parts = prepared.modules.map(module => `part '${moduleFileName(/** @type {string} */ (Reflect.get(module, \"id\")))}.dart';`).join(\"\\n\")\n\n  return `${parts}\\n\\n${dartRuntime}${outputSinkRuntime}`\n}\n\n/**\n * Renders exact Flutter template identity metadata.\n * @returns {string} Metadata YAML.\n */\nfunction renderMetadata() {\n  return `# This file tracks properties of this Semantifold-owned Flutter project.\nversion:\n  revision: ${flutterToolchain.revision}\n  channel: stable\nproject_type: app\n`\n}\n\n/**\n * Renders the closed analyzer configuration.\n * @returns {string} Analyzer YAML.\n */\nfunction renderAnalysisOptions() {\n  return `analyzer:\n  language:\n    strict-casts: true\n    strict-raw-types: true\n`\n}\n\n/**\n * Renders the SDK-only package manifest.\n * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @returns {string} Pubspec YAML.\n */\nfunction renderPubspec(prepared, spans) {\n  const configuration = prepared.configuration\n  const assetLines = prepared.assets.length == 0 ? \"\" : `\\n  assets:\\n${prepared.assets.map(({path}) => `    - ${path}`).join(\"\\n\")}\\n`\n\n  return configured(`${projectRoot}/pubspec.yaml`, spans, [\n    \"name: \", field(\"packageName\", configuration.packageName), \"\\npublish_to: none\\nversion: \",\n    field(\"versionName\", configuration.versionName), \"+\", field(\"versionCode\", String(configuration.versionCode)),\n    \"\\nenvironment:\\n  sdk: 3.13.3\\n  flutter: 3.47.4\\ndependencies:\\n  flutter:\\n    sdk: flutter\\ndev_dependencies:\\n  flutter_test:\\n    sdk: flutter\\nflutter:\\n  uses-material-design: true\\n\",\n    assetLines\n  ])\n}\n\n/**\n * Renders the exact Flutter SDK dependency lock.\n * @returns {string} Pub lock YAML.\n */\nfunction renderPubspecLock() {\n  const hosted = new Map(flutterLockedHostedPackages.map(package_ => [package_[0], package_]))\n  const sdk = new Map(flutterLockedSdkPackages)\n  const packageNames = [...hosted.keys(), ...sdk.keys()].sort()\n  const packages = packageNames.map(name => {\n    const sdkDependency = sdk.get(name)\n\n    if (sdkDependency) return `  ${name}:\n    dependency: ${sdkDependency == \"transitive\" ? sdkDependency : `\"${sdkDependency}\"`}\n    description: flutter\n    source: sdk\n    version: \"0.0.0\"`\n    const locked = hosted.get(name)\n\n    if (!locked) throw new TypeError(`Missing validated Flutter lock entry '${name}'.`)\n    const [, version, sha256] = locked\n    const renderedHash = /^[0-9]/u.test(sha256) ? `\"${sha256}\"` : sha256\n\n    return `  ${name}:\n    dependency: transitive\n    description:\n      name: ${name}\n      sha256: ${renderedHash}\n      url: \"https://pub.dev\"\n    source: hosted\n    version: \"${version}\"`\n  }).join(\"\\n\")\n\n  return `# Generated by pub\n# See https://dart.dev/tools/pub/glossary#lockfile\npackages:\n${packages}\nsdks:\n  dart: \"3.13.3\"\n  flutter: \"3.47.4\"\n`\n}\n\n/**\n * Renders the synthetic Material widget shell.\n * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @returns {string} Flutter entry source.\n */\nfunction renderWidgetApplication(prepared, spans) {\n  const entryClass = `SemantifoldModule${moduleName(prepared.program.entryModule)}`\n\n  return configured(`${projectRoot}/lib/main.dart`, spans, [\n    `import 'package:flutter/material.dart';\n\nimport 'src/semantic/semantifold.dart';\n\nvoid main() {\n  runApp(const SemantifoldApplication());\n}\n\nclass SemantifoldApplication extends StatelessWidget {\n  const SemantifoldApplication({super.key});\n\n  @override\n  Widget build(BuildContext context) {\n    final List<String> lines = ${entryClass}.semantifoldEntry();\n\n    return MaterialApp(\n      debugShowCheckedModeBanner: false,\n      title: '`, field(\"displayName\", dartEscape(prepared.configuration.displayName)), `',\n      home: Scaffold(\n        body: Center(\n          child: Semantics(\n            key: const Key('semantifold-output'),\n            container: true,\n            explicitChildNodes: true,\n            label: 'semantifold-output',\n            child: Text(lines.join('\\\\n')),\n          ),\n        ),\n      ),\n    );\n  }\n}\n`\n  ])\n}\n\n/**\n * Renders the semantic-entry determinism test.\n * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @returns {string} Flutter test source.\n */\nfunction renderLogicTest(prepared, spans) {\n  const entryClass = `SemantifoldModule${moduleName(prepared.program.entryModule)}`\n\n  return configured(`${projectRoot}/test/semantic_logic_test.dart`, spans, [\n    \"import 'package:flutter_test/flutter_test.dart';\\nimport 'package:\", field(\"packageName\", prepared.configuration.packageName),\n    `/src/semantic/semantifold.dart';\n\nvoid main() {\n  test('semantic entry is deterministic across fresh runs', () {\n    expect(\n      ${entryClass}.semantifoldEntry(),\n      ${entryClass}.semantifoldEntry(),\n    );\n  });\n}\n`\n  ])\n}\n\n/**\n * Renders the exact labelled widget test.\n * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @returns {string} Flutter widget test source.\n */\nfunction renderWidgetTest(prepared, spans) {\n  const entryClass = `SemantifoldModule${moduleName(prepared.program.entryModule)}`\n\n  return configured(`${projectRoot}/test/widget_test.dart`, spans, [\n    \"import 'package:flutter/material.dart';\\nimport 'package:flutter_test/flutter_test.dart';\\nimport 'package:\",\n    field(\"packageName\", prepared.configuration.packageName), `/main.dart';\nimport 'package:`, field(\"packageName\", prepared.configuration.packageName), `/src/semantic/semantifold.dart';\n\nvoid main() {\n  testWidgets('renders exact labelled semantic output', (\n    WidgetTester tester,\n  ) async {\n    final String expected = ${entryClass}.semantifoldEntry().join('\\\\n');\n\n    await tester.pumpWidget(const SemantifoldApplication());\n    final Finder output = find.byKey(const Key('semantifold-output'));\n\n    expect(output, findsOneWidget);\n    expect(\n      tester.widget<Semantics>(output).properties.label,\n      'semantifold-output',\n    );\n    expect(\n      find.descendant(of: output, matching: find.text(expected)),\n      findsOneWidget,\n    );\n  });\n}\n`\n  ])\n}\n\n/**\n * Renders the shared Android root build.\n * @returns {string} Gradle Kotlin source.\n */\nfunction renderAndroidRootBuild() {\n  return `allprojects {\n  repositories {\n    google()\n    mavenCentral()\n  }\n}\n\nval newBuildDir: Directory = rootProject.layout.buildDirectory.dir(\"../../build\").get()\nrootProject.layout.buildDirectory.value(newBuildDir)\n\nsubprojects {\n  project.layout.buildDirectory.value(newBuildDir.dir(project.name))\n  project.evaluationDependsOn(\":app\")\n}\n\ntasks.register<Delete>(\"clean\") {\n  delete(rootProject.layout.buildDirectory)\n}\n`\n}\n\n/**\n * Renders Flutter plugin and Android plugin ownership.\n * @param {import(\"../semantic/types.js\").FlutterApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @returns {string} Gradle settings source.\n */\nfunction renderAndroidSettings(configuration, spans) {\n  return configured(`${projectRoot}/android/settings.gradle.kts`, spans, [`pluginManagement {\n  val flutterSdkPath = run {\n    val properties = java.util.Properties()\n    file(\"local.properties\").inputStream().use { properties.load(it) }\n    requireNotNull(properties.getProperty(\"flutter.sdk\")) { \"flutter.sdk not set in local.properties\" }\n  }\n\n  includeBuild(\"$flutterSdkPath/packages/flutter_tools/gradle\")\n\n  repositories {\n    google()\n    mavenCentral()\n    gradlePluginPortal()\n  }\n}\n\nplugins {\n  id(\"dev.flutter.flutter-plugin-loader\") version \"1.0.0\"\n  id(\"com.android.application\") version \"${androidToolchain.androidGradlePlugin}\" apply false\n  id(\"org.jetbrains.kotlin.android\") version \"${androidToolchain.kotlinGradlePlugin}\" apply false\n}\n\nrootProject.name = \"`, field(\"packageName\", configuration.packageName), `\"\ninclude(\":app\")\n`])\n}\n\n/**\n * Renders deterministic Android Gradle properties.\n * @returns {string} Gradle properties.\n */\nfunction renderAndroidGradleProperties() {\n  return `android.builtInKotlin=false\nandroid.newDsl=false\nandroid.useAndroidX=true\nkotlin.stdlib.default.dependency=false\norg.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\n`\n}\n\n/**\n * Renders the Flutter Android application build.\n * @param {import(\"../semantic/types.js\").FlutterApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @returns {string} Application Gradle source.\n */\nfunction renderAndroidAppBuild(configuration, spans) {\n  return configured(`${projectRoot}/android/app/build.gradle.kts`, spans, [`plugins {\n  id(\"com.android.application\")\n  id(\"org.jetbrains.kotlin.android\")\n  id(\"dev.flutter.flutter-gradle-plugin\")\n}\n\nval semantifoldAcceptanceRoot = providers.environmentVariable(\"SEMANTIFOLD_FLUTTER_ACCEPTANCE_ROOT\").orNull\n  ?: throw GradleException(\"SEMANTIFOLD_FLUTTER_INFRASTRUCTURE: SEMANTIFOLD_FLUTTER_ACCEPTANCE_ROOT is required\")\nval semantifoldDebugKeystore = file(\"$semantifoldAcceptanceRoot/debug.keystore\")\nif (!semantifoldDebugKeystore.isFile) {\n  throw GradleException(\"SEMANTIFOLD_FLUTTER_INFRASTRUCTURE: ephemeral debug keystore is missing\")\n}\n\nconfigurations.configureEach {\n  exclude(group = \"androidx.profileinstaller\", module = \"profileinstaller\")\n}\n\nandroid {\n  namespace = \"`, field(\"applicationId\", configuration.applicationId), `\"\n  compileSdk = `, field(\"compileSdk\", String(configuration.compileSdk)), `\n  buildToolsVersion = \"`, field(\"buildToolsVersion\", configuration.buildToolsVersion), `\"\n  ndkVersion = \"${androidToolchain.ndk}\"\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\", configuration.versionName), `\"\n  }\n\n  signingConfigs {\n    getByName(\"debug\") {\n      storeFile = semantifoldDebugKeystore\n      storePassword = \"android\"\n      keyAlias = \"androiddebugkey\"\n      keyPassword = \"android\"\n    }\n  }\n\n  buildTypes {\n    getByName(\"debug\") {\n      signingConfig = signingConfigs.getByName(\"debug\")\n    }\n  }\n\n  buildFeatures {\n    buildConfig = false\n  }\n\n  compileOptions {\n    sourceCompatibility = JavaVersion.VERSION_17\n    targetCompatibility = JavaVersion.VERSION_17\n  }\n\n  lint {\n    abortOnError = true\n    checkDependencies = true\n    disable += \"MissingApplicationIcon\"\n    disable += \"OldTargetApi\"\n    disable += \"GradleDependency\"\n    warningsAsErrors = true\n  }\n}\n\nflutter {\n  source = \"../..\"\n}\n`])\n}\n\n/**\n * Renders the permission-free Android manifest.\n * @param {import(\"../semantic/types.js\").FlutterApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @returns {string} Android manifest XML.\n */\nfunction renderAndroidManifest(configuration, spans) {\n  return configured(`${projectRoot}/android/app/src/main/AndroidManifest.xml`, spans, [\n    `<manifest\n  xmlns:android=\"http://schemas.android.com/apk/res/android\"\n  xmlns:tools=\"http://schemas.android.com/tools\">\n  <permission tools:node=\"removeAll\" />\n  <uses-permission tools:node=\"removeAll\" />\n  <application\n    android:allowBackup=\"false\"\n    android:dataExtractionRules=\"@xml/data_extraction_rules\"\n    android:fullBackupContent=\"@xml/backup_rules\"\n    android:label=\"`, field(\"displayName\", xmlEscape(configuration.displayName)), `\"\n    android:name=\"\\${applicationName}\"\n    android:supportsRtl=\"true\">\n    <activity\n      android:name=\".`, field(\"activityClassName\", configuration.activityClassName), `\"\n      android:configChanges=\"orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode\"\n      android:exported=\"true\"\n      android:hardwareAccelerated=\"true\"\n      android:launchMode=\"singleTop\"\n      android:taskAffinity=\"\"\n      android:theme=\"@style/LaunchTheme\"\n      android:windowSoftInputMode=\"adjustResize\">\n      <meta-data\n        android:name=\"io.flutter.embedding.android.NormalTheme\"\n        android:resource=\"@style/NormalTheme\" />\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    <meta-data android:name=\"flutterEmbedding\" android:value=\"2\" />\n    <provider android:name=\"androidx.startup.InitializationProvider\" tools:node=\"remove\" />\n  </application>\n</manifest>\n`\n  ])\n}\n\n/**\n * Renders the Java Flutter activity launcher.\n * @param {import(\"../semantic/types.js\").FlutterApplicationConfiguration} configuration - Normalized configuration.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @returns {string} Java source.\n */\nfunction renderAndroidActivity(configuration, spans) {\n  return configured(`${projectRoot}/android/app/src/main/java/${configuration.applicationId.replaceAll(\".\", \"/\")}/${configuration.activityClassName}.java`, spans, [\n    \"package \", field(\"applicationId\", configuration.applicationId), `;\n\nimport io.flutter.embedding.android.FlutterActivity;\n\npublic final class `, field(\"activityClassName\", configuration.activityClassName), ` extends FlutterActivity {\n}\n`\n  ])\n}\n\n/**\n * Renders platform launch and host styles.\n * @param {boolean} night - Whether to render the night theme.\n * @returns {string} Android resource XML.\n */\nfunction renderAndroidStyles(night) {\n  return `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<resources>\n  <style name=\"LaunchTheme\" parent=\"@android:style/Theme.${night ? \"Black\" : \"Light\"}.NoTitleBar\">\n    <item name=\"android:windowBackground\">@drawable/launch_background</item>\n  </style>\n  <style name=\"NormalTheme\" parent=\"@android:style/Theme.${night ? \"Black\" : \"Light\"}.NoTitleBar\">\n    <item name=\"android:windowBackground\">?android:colorBackground</item>\n  </style>\n</resources>\n`\n}\n\n/**\n * Renders a platform launch background.\n * @returns {string} Android resource XML.\n */\nfunction renderLaunchBackground() {\n  return `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<layer-list xmlns:android=\"http://schemas.android.com/apk/res/android\">\n  <item android:drawable=\"?android:colorBackground\" />\n</layer-list>\n`\n}\n\n/**\n * Renders complete legacy backup exclusions.\n * @returns {string} Android resource 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 complete Android 12+ backup exclusions.\n * @returns {string} Android resource XML.\n */\nfunction renderDataExtractionRules() {\n  const exclusions = [\"root\", \"file\", \"database\", \"sharedpref\", \"external\", \"device_root\", \"device_file\", \"device_database\", \"device_sharedpref\"]\n    .map(domain => `    <exclude domain=\"${domain}\" path=\".\" />`).join(\"\\n\")\n\n  return `<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<data-extraction-rules>\n  <cloud-backup>\n${exclusions}\n  </cloud-backup>\n  <device-transfer>\n${exclusions}\n  </device-transfer>\n</data-extraction-rules>\n`\n}\n\n/**\n * Renders the ownership, toolchain, provenance, and platform-status manifest.\n * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared application.\n * @param {import(\"../semantic/types.js\").GeneratedSetArtifact[]} artifacts - Owned artifacts except this manifest.\n * @param {string} manifestPath - Manifest artifact path.\n * @param {ConfigurationSpan[]} spans - Configuration provenance spans.\n * @returns {string} Canonical manifest JSON.\n */\nfunction renderProjectManifest(prepared, artifacts, manifestPath, spans) {\n  const inputPaths = new Set(prepared.assets.map(({fullPath}) => fullPath))\n  const semanticArtifacts = artifacts.filter(artifact => artifact.provenance.kind == \"text\")\n\n  return stringifyCanonicalJson({\n    configuration: prepared.configuration,\n    generator: {name: \"semantifold\", version: generatorVersion},\n    ownership: {\n      excludedPathPatterns,\n      ownedPaths: [...artifacts.map(({path}) => path), manifestPath],\n      ownedRoot: projectRoot,\n      sha256: artifacts.map(artifact => ({path: artifact.path, sha256: hashContent(artifact.content)}))\n    },\n    platforms: {\n      android: {acceptance: \"tensorbuzz-kvm\", artifacts: \"generated\"},\n      ios: {\n        acceptance: \"deferred\",\n        artifacts: \"omitted\",\n        reason: \"Owner direction defers macOS, Xcode, Apple SDK, signing, and iOS Simulator qualification.\"\n      }\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.assets.map(asset => ({\n        contentKind: asset.contentKind,\n        mediaType: asset.mediaType,\n        path: asset.fullPath,\n        sha256: asset.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: \"SemantifoldFlutterProject\",\n    semanticProgram: semanticProgramManifest(prepared),\n    target: \"flutter\",\n    toolchain: {android: androidToolchain, flutter: flutterToolchain},\n    version: 1\n  })\n}\n\n/**\n * Describes the complete semantic program inside the application manifest.\n * @param {ReturnType<typeof preflightFlutterApplication>} prepared - Prepared project.\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 Flutter 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      generatedArtifact: prepared.modulePaths.get(entryId),\n      generatedFunctionIdentity: `SemantifoldModule${moduleName(entryId)}.semantifoldEntry`,\n      moduleId: entryId,\n      widgetArtifact: `${projectRoot}/lib/main.dart`\n    },\n    modules,\n    schema: \"SemantifoldFlutterSemanticProgram\",\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 * Normalizes and validates the closed application configuration.\n * @param {unknown} candidate - Candidate configuration.\n * @returns {import(\"../semantic/types.js\").FlutterApplicationConfiguration} 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(\"Flutter application configuration must be a closed plain object.\")\n  }\n  const configuration = /** @type {import(\"../semantic/types.js\").FlutterApplicationConfigurationInput} */ (candidate)\n  const packageName = configuration.packageName ?? \"semantifold_generated\"\n  const organization = configuration.organization ?? \"dev.semantifold\"\n  const applicationId = configuration.applicationId ?? `${organization}.generated`\n  const activityClassName = configuration.activityClassName ?? \"MainActivity\"\n  const displayName = configuration.displayName ?? \"Semantifold\"\n  const minimumSdk = configuration.minimumSdk ?? 23\n  const targetSdk = configuration.targetSdk ?? 35\n  const compileSdk = configuration.compileSdk ?? 35\n  const buildToolsVersion = configuration.buildToolsVersion ?? \"35.0.0\"\n  const versionCode = configuration.versionCode ?? 1\n  const versionName = configuration.versionName ?? \"1.0.0\"\n\n  if (typeof packageName != \"string\" || !/^[a-z][a-z0-9_]*$/u.test(packageName) || dartKeywords.has(packageName) ||\n    forbiddenPackageNames.has(packageName)) invalidConfiguration(\"Dart package name must be a non-reserved lowercase underscore identifier.\")\n  if (typeof organization != \"string\" || !isReverseDns(organization, 2)) {\n    invalidConfiguration(\"Organization must be a lowercase reverse-DNS identity with at least two segments.\")\n  }\n  if (typeof applicationId != \"string\" || !isReverseDns(applicationId, 3) || !applicationId.startsWith(`${organization}.`)) {\n    invalidConfiguration(\"Application ID must extend the exact organization as lowercase reverse DNS.\")\n  }\n  if (typeof activityClassName != \"string\" || !/^[A-Z][A-Za-z0-9]*$/u.test(activityClassName) ||\n    javaKeywords.has(activityClassName)) invalidConfiguration(\"Activity class name must be an ASCII upper-camel Java identifier.\")\n  if (androidRunnerBaseClassNames.has(activityClassName)) {\n    invalidConfiguration(\"Activity class name must not collide with the imported Flutter launcher base class.\")\n  }\n  if (typeof displayName != \"string\" || displayName.length == 0 || displayName.trim() != displayName ||\n    [...displayName].length > 64 || !hasOnlyUnicodeScalars(displayName) || /[\\p{Cc}\\p{Zl}\\p{Zp}\\uFFFE\\uFFFF]/u.test(displayName)) {\n    invalidConfiguration(\"Display name must be a non-empty single-line Unicode scalar string of at most 64 characters.\")\n  }\n  if (minimumSdk !== 23 || targetSdk !== 35 || compileSdk !== 35) {\n    invalidConfiguration(\"SDK levels must reuse the qualified minimum 23, target 35, and compile 35 Android matrix.\")\n  }\n  if (buildToolsVersion != \"35.0.0\") 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) || versionName.includes(\"+\")) {\n    invalidConfiguration(\"Version name must be a canonical semantic version without build metadata.\")\n  }\n  if (configuration.permissions !== undefined &&\n    (!isDenseArray(configuration.permissions) || configuration.permissions.length != 0)) {\n    invalidConfiguration(\"The baseline Flutter permission set must be empty.\")\n  }\n\n  return {activityClassName, applicationId, buildToolsVersion, compileSdk, displayName, minimumSdk, organization,\n    packageName, targetSdk, versionCode, versionName}\n}\n\n/**\n * Snapshots and validates exact caller assets.\n * @param {unknown} candidate - Candidate asset collection.\n * @returns {FlutterAsset[]} Normalized assets.\n */\nfunction normalizeAssets(candidate) {\n  if (candidate === undefined) return []\n  if (!isDenseArray(candidate)) invalidAsset(\"Flutter assets must be a dense array.\")\n  /** @type {FlutterAsset[]} */\n  const assets = []\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 != assetFields.size ||\n      Object.keys(item).some(key => !assetFields.has(key))) invalidAsset(`Asset ${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) || !String(path).startsWith(\"assets/\")) {\n      invalidAsset(`Asset ${index} requires a safe portable path below 'assets'.`)\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      invalidAsset(`Asset '${path}' requires non-empty exact content.`)\n    }\n    if (typeof mediaType != \"string\" || !mediaTypePattern.test(mediaType) || /[\\r\\n]/u.test(mediaType)) {\n      invalidAsset(`Asset '${path}' requires an explicit valid 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      invalidAsset(`Asset '${path}' SHA-256 does not match its exact content.`)\n    }\n    assets.push({content: snapshot, contentKind: typeof snapshot == \"string\" ? \"text\" : \"binary\",\n      fullPath: `${projectRoot}/${path}`, mediaType, path, sha256})\n  }\n  assets.sort((left, right) => left.fullPath < right.fullPath ? -1 : left.fullPath > right.fullPath ? 1 : 0)\n  const conflict = findPortableArtifactPathConflict(assets.map(({fullPath}) => fullPath))\n\n  if (conflict) invalidAsset(`Asset path '${conflict.path}' has a ${conflict.kind} conflict.`)\n\n  return assets\n}\n\n/**\n * Enumerates every generator-owned application path.\n * @param {import(\"../semantic/types.js\").FlutterApplicationConfiguration} configuration - Normalized configuration.\n * @param {Map<string, string>} modulePaths - Semantic module paths.\n * @returns {string[]} Complete paths.\n */\nfunction applicationPaths(configuration, modulePaths) {\n  const packagePath = configuration.applicationId.replaceAll(\".\", \"/\")\n\n  return [\n    `${projectRoot}/.metadata`,\n    `${projectRoot}/analysis_options.yaml`,\n    `${projectRoot}/android/app/build.gradle.kts`,\n    `${projectRoot}/android/app/src/main/AndroidManifest.xml`,\n    `${projectRoot}/android/app/src/main/java/${packagePath}/${configuration.activityClassName}.java`,\n    `${projectRoot}/android/app/src/main/res/drawable/launch_background.xml`,\n    `${projectRoot}/android/app/src/main/res/values-night/styles.xml`,\n    `${projectRoot}/android/app/src/main/res/values/styles.xml`,\n    `${projectRoot}/android/app/src/main/res/xml/backup_rules.xml`,\n    `${projectRoot}/android/app/src/main/res/xml/data_extraction_rules.xml`,\n    `${projectRoot}/android/build.gradle.kts`,\n    `${projectRoot}/android/gradle.properties`,\n    `${projectRoot}/android/settings.gradle.kts`,\n    `${projectRoot}/lib/main.dart`,\n    ...modulePaths.values(),\n    `${projectRoot}/lib/src/semantic/semantifold.dart`,\n    `${projectRoot}/pubspec.lock`,\n    `${projectRoot}/pubspec.yaml`,\n    `${projectRoot}/test/semantic_logic_test.dart`,\n    `${projectRoot}/test/widget_test.dart`,\n    `${projectRoot}/semantifold-project.json`\n  ]\n}\n\n/**\n * Converts one normalized asset to an owned artifact.\n * @param {FlutterAsset} asset - Normalized asset.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Generated asset.\n */\nfunction assetArtifact(asset) {\n  const reason = `Exact caller-provided Flutter asset (sha256:${asset.sha256}).`\n\n  if (typeof asset.content == \"string\") return {...syntheticText(asset.fullPath, \"resource\", asset.content, reason), mediaType: asset.mediaType}\n  const content = new Uint8Array(asset.content)\n\n  return {\n    content,\n    contentKind: \"binary\",\n    mediaType: asset.mediaType,\n    ownership: \"generated\",\n    path: asset.fullPath,\n    provenance: {kind: \"bytes\", mapping: createByteMapping({\n      byteLength: content.byteLength,\n      path: asset.fullPath,\n      ranges: [{generated: {end: content.byteLength, start: 0},\n        origin: {kind: \"synthetic\", reason, relatedOrigins: []}, role: \"asset\"}]\n    })},\n    role: \"resource\"\n  }\n}\n\n/**\n * Creates a synthetic text artifact.\n * @param {string} path - Artifact path.\n * @param {import(\"../semantic/types.js\").GeneratedArtifactRole} role - Artifact role.\n * @param {string} content - Exact content.\n * @param {string} reason - Synthetic provenance reason.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Generated 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 text whose configuration spans are recorded separately.\n * @param {string} path - Artifact path.\n * @param {import(\"../semantic/types.js\").GeneratedArtifactRole} role - Artifact role.\n * @param {string} content - Exact content.\n * @param {string} reason - Synthetic provenance reason.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Generated artifact.\n */\nfunction configuredText(path, role, content, reason) {\n  return syntheticText(path, role, content, reason)\n}\n\n/**\n * Selects an exact media type from an owned path.\n * @param {string} path - Artifact path.\n * @returns {string} Media type.\n */\nfunction mediaTypeFor(path) {\n  if (path.endsWith(\".dart\")) return \"text/x-dart\"\n  if (path.endsWith(\".json\")) return \"application/json\"\n  if (path.endsWith(\".yaml\") || path.endsWith(\".lock\")) return \"application/yaml\"\n  if (path.endsWith(\".xml\")) return \"application/xml\"\n  if (path.endsWith(\".java\")) return \"text/x-java-source\"\n  if (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.\n * @param {string} value - Rendered value.\n * @returns {{field: string, value: string}} Marked value.\n */\nfunction field(fieldName, value) {\n  return {field: fieldName, value}\n}\n\n/**\n * Joins configured parts while recording exact output spans.\n * @param {string} path - Artifact path.\n * @param {ConfigurationSpan[]} spans - Configuration provenance sink.\n * @param {(string | {field: string, value: string})[]} parts - Literal and configured parts.\n * @returns {string} Rendered content.\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 exact generated ranges for one configuration field.\n * @param {ConfigurationSpan[]} spans - Recorded spans.\n * @param {string} fieldName - Configuration field.\n * @returns {{path: string, ranges: {end: number, start: number}[]}[]} Grouped 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 * Checks whether provenance refers to one source file.\n * @param {import(\"../semantic/types.js\").SemanticOrigin} origin - Semantic origin.\n * @param {string} filename - Source filename.\n * @returns {boolean} Whether the origin references the source.\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 artifact content.\n * @param {string | Uint8Array} content - Artifact content.\n * @returns {string} Lowercase SHA-256.\n */\nfunction hashContent(content) {\n  return createHash(\"sha256\").update(content).digest(\"hex\")\n}\n\n/**\n * Serializes a recursively sorted JSON value.\n * @param {unknown} value - JSON-compatible value.\n * @returns {string} Canonical indented JSON.\n */\nfunction stringifyCanonicalJson(value) {\n  return `${JSON.stringify(sortJson(value), null, 2)}\\n`\n}\n\n/**\n * Recursively sorts object keys without reordering arrays.\n * @param {unknown} value - JSON-compatible value.\n * @returns {unknown} Sorted 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 * Validates a lowercase reverse-DNS identity.\n * @param {string} value - Candidate identity.\n * @param {number} segments - Required minimum segment count.\n * @returns {boolean} Whether the identity is valid.\n */\nfunction isReverseDns(value, segments) {\n  const parts = value.split(\".\")\n\n  return parts.length >= segments && parts.every(part => /^[a-z][a-z0-9_]*$/u.test(part) && !javaKeywords.has(part))\n}\n\n/**\n * Derives one stable Dart class suffix.\n * @param {string} id - Semantic module identity.\n * @returns {string} Dart class suffix.\n */\nfunction moduleName(id) {\n  return id.split(/[._-]+/u).map(part => `${part[0].toUpperCase()}${part.slice(1)}`).join(\"\")\n}\n\n/**\n * Derives one stable semantic part filename.\n * @param {string} id - Semantic module identity.\n * @returns {string} Dart filename.\n */\nfunction moduleFileName(id) {\n  return id.replaceAll(/[.-]/gu, \"_\")\n}\n\n/**\n * Allocates a collision-free private output sink binding.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Semantic module.\n * @returns {string} Dart binding name.\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 every block-owned binding name.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @param {Set<string>} bindings - Mutable name set.\n * @returns {void}\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 * Wraps one module in an explicit semantic project.\n * @param {import(\"../semantic/types.js\").SemanticModule | undefined} candidate - Candidate module.\n * @returns {import(\"../semantic/types.js\").SemanticProgram} Normalized project.\n */\nfunction normalizeSingleModule(candidate) {\n  if (!isPlainObject(candidate)) unsupportedCapability(\"flutter\", \"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(\"flutter\", \"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 * Converts one module declaration to an explicit application export.\n * @param {{id?: string, location: import(\"../semantic/types.js\").SourceLocation, name: string}} declaration - 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: \"Export\", location: declaration.location, symbolKind}\n}\n\n/**\n * Re-keys one standalone module for application-project ownership.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Standalone module.\n * @param {string} moduleId - Stable application module identity.\n * @returns {void}\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 semantic declaration identities recursively.\n   * @param {unknown} value - Candidate semantic value.\n   * @returns {void}\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 an XML attribute value.\n * @param {string} value - Raw value.\n * @returns {string} Escaped 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 single-quoted Dart literal body.\n * @param {string} value - Raw value.\n * @returns {string} Escaped value.\n */\nfunction dartEscape(value) {\n  return value.replaceAll(\"\\\\\", \"\\\\\\\\\").replaceAll(\"'\", \"\\\\'\").replaceAll(\"$\", \"\\\\$\")\n}\n\n/**\n * Checks for a plain string-keyed object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is plain.\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-input diagnostic.\n * @param {string} message - Diagnostic detail.\n * @returns {never} Never returns.\n */\nfunction invalidInput(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_INPUT\", language: \"flutter\", message})\n}\n\n/**\n * Throws a stable invalid-configuration diagnostic.\n * @param {string} message - Diagnostic detail.\n * @returns {never} Never returns.\n */\nfunction invalidConfiguration(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_CONFIGURATION\", language: \"flutter\", message})\n}\n\n/**\n * Throws a stable invalid-asset diagnostic.\n * @param {string} message - Diagnostic detail.\n * @returns {never} Never returns.\n */\nfunction invalidAsset(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_ASSET\", language: \"flutter\", message})\n}\n\n/**\n * Throws a stable invalid-path diagnostic.\n * @param {string} message - Diagnostic detail.\n * @returns {never} Never returns.\n */\nfunction invalidPath(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_PATH\", language: \"flutter\", message})\n}\n"]}