semantifold 0.3.0 → 0.5.0

package/build/src/backends/ios.js

@@ -0,0 +1,1503 @@
+// @ts-check
+import { createHash } from "node:crypto";
+import { isDenseArray } from "../array.js";
+import { findPortableArtifactPathConflict, isSafeArtifactPath } from "../artifact-path.js";
+import { createByteMapping } from "../binary-mapping.js";
+import { SemantifoldDiagnostic, unsupportedCapability } from "../diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { preflightSemanticProgram } from "./program.js";
+import { emitScalarType, emitStringLiteral } from "./scalars.js";
+import { SourceWriter } from "./writer.js";
+/** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
+const iosSourceLanguages = new Set([
+    "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart"
+]);
+const configurationFields = new Set([
+    "bundleIdentifier", "capabilities", "deploymentTarget", "displayName", "entitlements", "infoPlist", "lifecycle",
+    "moduleName", "organizationPrefix", "permissions", "privacyDeclarations", "productName", "resourceRoot", "sourceRoot"
+]);
+const assetFields = new Set(["content", "mediaType", "path", "sha256"]);
+const generatorVersion = "0.3.0";
+const excludedPathPatterns = Object.freeze([
+    "**/*.xcuserstate",
+    "**/xcuserdata/**",
+    ".swiftpm/**",
+    "DerivedData/**",
+    "build/**"
+]);
+const mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+(?:;[\u0020-\u007e]+)?$/u;
+const binaryOperations = Object.freeze({
+    BooleanAnd: "&&",
+    BooleanEqual: "==",
+    BooleanNotEqual: "!=",
+    BooleanOr: "||",
+    IntegerAdd: "+",
+    IntegerEqual: "==",
+    IntegerGreaterThan: ">",
+    IntegerGreaterThanOrEqual: ">=",
+    IntegerLessThan: "<",
+    IntegerLessThanOrEqual: "<=",
+    IntegerMultiply: "*",
+    IntegerNotEqual: "!=",
+    IntegerSubtract: "-",
+    StringConcat: "+",
+    StringEqual: "==",
+    StringNotEqual: "!="
+});
+const unaryOperations = Object.freeze({ BooleanNot: "!", IntegerNegate: "-" });
+const iosSwiftRuntime = `final class SemantifoldOutputSink {
+  private(set) var lines: [String] = []
+
+  func write(_ value: Int64) {
+    lines.append(String(value))
+  }
+
+  func write(_ value: Bool) {
+    lines.append(value ? "true" : "false")
+  }
+
+  func write(_ value: String) {
+    lines.append(value)
+  }
+}
+
+func semantifold_string_equal(_ left: String, _ right: String) -> Bool {
+  return left.unicodeScalars.elementsEqual(right.unicodeScalars)
+}
+
+func semantifold_string_not_equal(_ left: String, _ right: String) -> Bool {
+  return !left.unicodeScalars.elementsEqual(right.unicodeScalars)
+}
+
+func semantifold_keep_mutable<T>(_ value: inout T) {
+}
+`;
+/** @typedef {{content: string, field: string}} ConfigurationFragment */
+/** @typedef {string | ConfigurationFragment} ConfigurationTextPart */
+/** @typedef {string | readonly ConfigurationTextPart[]} ConfigurationLine */
+/** @typedef {{end: number, field: string, start: number}} ConfigurationSpan */
+/** @typedef {{content: string, configurationSpans: ConfigurationSpan[]}} RenderedConfigurationText */
+/** @typedef {{end: number, field: string, path: string, start: number}} ConfigurationArtifactSpan */
+/** Records configuration causality while an owning renderer emits text. */
+class ConfigurationTextWriter {
+    constructor() {
+        this.content = "";
+        /** @type {ConfigurationSpan[]} */
+        this.configurationSpans = [];
+    }
+    /**
+     * Appends literal or field-owned text.
+     * @param {ConfigurationTextPart | readonly ConfigurationTextPart[]} value - Ordered output text.
+     */
+    append(value) {
+        const parts = Array.isArray(value) ? value : [value];
+        for (const part of parts) {
+            if (typeof part == "string") {
+                this.content += part;
+            }
+            else {
+                const start = this.content.length;
+                this.content += part.content;
+                this.configurationSpans.push({ end: this.content.length, field: part.field, start });
+            }
+        }
+    }
+    /**
+     * Finishes renderer-owned text collection.
+     * @returns {RenderedConfigurationText} Finished content and causal spans.
+     */
+    finish() {
+        return { configurationSpans: this.configurationSpans, content: this.content };
+    }
+}
+/**
+ * Marks text as causally owned by one normalized configuration field.
+ * @param {string} field - Configuration field.
+ * @param {string} content - Exact rendered token content.
+ * @returns {ConfigurationFragment} Tagged token.
+ */
+function configurationFragment(field, content) {
+    return { content, field };
+}
+/**
+ * Preflights one complete project against the delivered Swift Tasks 001-004 profile.
+ * @param {object} input - iOS application generation input.
+ * @param {import("../semantic/types.js").SemanticModule} [input.module] - Single module to normalize.
+ * @param {import("../semantic/types.js").SemanticProgram} [input.program] - Caller-owned Task 010 project.
+ * @param {import("../semantic/types.js").IosApplicationConfigurationInput} [input.configuration] - Closed application configuration.
+ * @param {import("../semantic/types.js").IosApplicationAssetInput[]} [input.assets] - Exact caller-provided assets.
+ * @returns {{assets: import("../semantic/types.js").IosApplicationAssetInput[], configuration: import("../semantic/types.js").IosApplicationConfiguration, modulePaths: Map<string, string>, modules: import("../semantic/types.js").SemanticModule[], program: import("../semantic/types.js").SemanticProgram, sources: {content: string, filename: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} Prepared application program.
+ */
+export function preflightIosApplication(input) {
+    if (!isPlainObject(input) || Boolean(input.module) == Boolean(input.program)) {
+        throw new SemantifoldDiagnostic({
+            code: "INVALID_APPLICATION_INPUT",
+            language: "ios",
+            message: "iOS application generation requires exactly one semantic module or program."
+        });
+    }
+    const configuration = normalizeConfiguration(input.configuration);
+    const program = input.program ?? normalizeSingleModule(input.module);
+    const prepared = preflightSemanticProgram({
+        backendLanguage: "swift",
+        diagnosticLanguage: "ios",
+        program,
+        sourceLanguages: iosSourceLanguages
+    });
+    const modulePaths = new Map(prepared.modules.map(module => [
+        /** @type {string} */ (Reflect.get(module, "id")),
+        `${configuration.sourceRoot}/Generated/${moduleName(/** @type {string} */ (Reflect.get(module, "id")))}.swift`
+    ]));
+    const assets = normalizeAssets(input.assets, configuration.resourceRoot);
+    const conflict = findPortableArtifactPathConflict([
+        `${configuration.sourceRoot}/Generated/SemantifoldRuntime.swift`,
+        ...modulePaths.values(),
+        `${configuration.resourceRoot}/Contents.json`,
+        ...assets.map(({ path }) => path)
+    ]);
+    if (conflict)
+        invalidPath(`Application artifact path '${conflict.path}' has a ${conflict.kind} conflict${conflict.other ? ` with '${conflict.other}'` : ""}.`);
+    return { ...prepared, assets, configuration, modulePaths };
+}
+/**
+ * Generates the deterministic semantic Swift portion of one iOS application artifact set.
+ * @param {Parameters<typeof preflightIosApplication>[0]} input - iOS generation request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], metadata: {applicationManifest: string, platformQualification: string}, target: "ios"}} Candidate artifact set.
+ */
+export function generateIosApplication(input) {
+    const prepared = preflightIosApplication(input);
+    const semanticArtifacts = renderSemanticArtifacts(prepared);
+    const applicationPaths = applicationArtifactPaths(prepared);
+    const project = renderPbxProject(prepared, applicationPaths);
+    const scheme = renderSharedScheme(prepared);
+    const baseConfiguration = renderBaseConfiguration(prepared.configuration);
+    const infoPlist = renderInfoPlist(prepared.configuration);
+    const unitTests = renderUnitTests(prepared.configuration);
+    const uiTests = renderUiTests(prepared.configuration);
+    const configuration = prepared.configuration;
+    const entryNamespace = `SemantifoldModule${moduleName(prepared.program.entryModule)}`;
+    const app = `import SwiftUI
+
+@main
+struct SemantifoldApplication: App {
+  var body: some Scene {
+    WindowGroup {
+      SemantifoldOutputView(lines: SemantifoldBridge.run())
+    }
+  }
+}
+`;
+    const bridge = `enum SemantifoldBridge {
+  static func run() -> [String] {
+    return ${entryNamespace}.semantifoldEntry()
+  }
+}
+`;
+    const view = `import SwiftUI
+
+struct SemantifoldOutputView: View {
+  let lines: [String]
+
+  var body: some View {
+    Text(lines.joined(separator: "\\n"))
+      .accessibilityIdentifier("semantifold-output")
+  }
+}
+`;
+    const product = configuration.productName;
+    /** @type {ConfigurationArtifactSpan[]} */
+    const configurationSpans = [];
+    const artifacts = [
+        configuredSyntheticText(`${product}.xcodeproj/project.pbxproj`, "manifest", project, configurationSpans, "Canonical deterministic Xcode project structure."),
+        configuredSyntheticText(`${product}.xcodeproj/xcshareddata/xcschemes/${product}.xcscheme`, "support", scheme, configurationSpans, "Canonical shared Xcode application/test scheme."),
+        configuredSyntheticText("Configuration/Base.xcconfig", "support", baseConfiguration, configurationSpans, "Closed unsigned iOS build configuration."),
+        configuredSyntheticText("Configuration/Info.plist", "support", infoPlist, configurationSpans, "Allowlisted iOS application property list."),
+        ...semanticArtifacts,
+        syntheticText("Sources/Application/App.swift", "entry", app, "Synthetic SwiftUI application lifecycle."),
+        syntheticText("Sources/Application/SemantifoldBridge.swift", "support", bridge, "Synthetic bridge from SwiftUI to the semantic entry."),
+        syntheticText("Sources/Application/SemantifoldOutputView.swift", "support", view, "Synthetic stable text output view and accessibility identifier."),
+        syntheticText("Assets.xcassets/Contents.json", "resource", stringifyCanonicalJson({
+            info: { author: "semantifold", version: 1 }
+        }), "Base asset-catalog metadata; no application icon is synthesized."),
+        ...prepared.assets.map(assetArtifact),
+        configuredSyntheticText(`Tests/${product}Tests.swift`, "support", unitTests, configurationSpans, "Synthetic pure-logic determinism XCTest source."),
+        configuredSyntheticText(`UITests/${product}UITests.swift`, "support", uiTests, configurationSpans, "Synthetic XCUI accessibility-route test source.")
+    ];
+    const manifestPath = "semantifold-project.json";
+    artifacts.push(syntheticText(manifestPath, "manifest", renderProjectManifest(prepared, artifacts, manifestPath, configurationSpans), "Versioned iOS project ownership and provenance manifest."));
+    return {
+        artifacts,
+        metadata: { applicationManifest: manifestPath, platformQualification: "deferred" },
+        target: "ios"
+    };
+}
+/**
+ * Renders the complete deterministic application ownership and provenance record.
+ * @param {ReturnType<typeof preflightIosApplication>} prepared - Fully preflighted application.
+ * @param {import("../semantic/types.js").GeneratedSetArtifact[]} artifacts - All non-manifest output artifacts.
+ * @param {string} manifestPath - Owned manifest path.
+ * @param {ConfigurationArtifactSpan[]} configurationSpans - Renderer-owned configuration ranges.
+ * @returns {string} Canonical manifest JSON.
+ */
+function renderProjectManifest(prepared, artifacts, manifestPath, configurationSpans) {
+    const assetPaths = new Set(prepared.assets.map(({ path }) => path));
+    const semanticArtifacts = artifacts.filter(artifact => artifact.provenance.kind == "text");
+    const configuration = prepared.configuration;
+    return stringifyCanonicalJson({
+        configuration,
+        generator: { name: "semantifold", version: generatorVersion },
+        ownership: {
+            excludedPathPatterns,
+            ownedPaths: [...artifacts.map(({ path }) => path), manifestPath]
+        },
+        platformRequirements: {
+            appleSdk: { status: "deferred" },
+            iosSimulator: { status: "deferred" },
+            macosHost: { status: "deferred" },
+            swiftc: { status: "deferred" },
+            xcode: { status: "deferred" },
+            xctest: { status: "deferred" },
+            xcuiautomation: { status: "deferred" }
+        },
+        provenance: {
+            assets: prepared.assets.map(asset => ({
+                contentKind: typeof asset.content == "string" ? "text" : "binary",
+                mediaType: asset.mediaType,
+                path: asset.path,
+                sha256: asset.sha256
+            })),
+            configuration: Object.keys(configuration).sort().map(field => ({
+                field,
+                manifestPointer: `/configuration/${field}`,
+                outputs: configurationOutputCitations(configurationSpans, field)
+            })),
+            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" && !assetPaths.has(artifact.path))
+                    .map(({ path }) => path),
+                manifestPath
+            ]
+        },
+        schema: "SemantifoldIosProject",
+        semanticProgram: semanticProgramManifest(prepared),
+        target: "ios",
+        version: 1
+    });
+}
+/**
+ * Records stable semantic input identities and their generated Swift linkage.
+ * @param {ReturnType<typeof preflightIosApplication>} prepared - Fully preflighted application.
+ * @returns {Record<string, unknown>} Versioned semantic-program manifest section.
+ */
+function semanticProgramManifest(prepared) {
+    const moduleIds = new Map(prepared.program.modules.map((module, index) => [module.id, index]));
+    const sourceContent = new Map(prepared.sources.map(source => [source.filename, source.content]));
+    const modules = prepared.program.modules.map(module => {
+        const id = module.id;
+        const path = /** @type {string} */ (prepared.modulePaths.get(id));
+        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 iOS module '${id}' lost its source ownership.`);
+        const dependencies = [...new Set(module.imports.map(({ moduleId }) => moduleId))]
+            .sort((left, right) => /** @type {number} */ (moduleIds.get(left)) - /** @type {number} */ (moduleIds.get(right)));
+        return {
+            dependencies,
+            generatedArtifacts: [path],
+            id,
+            namespace: `SemantifoldModule${moduleName(id)}`,
+            source: {
+                filename: source.filename,
+                id: source.id,
+                sha256: createHash("sha256").update(content).digest("hex")
+            }
+        };
+    });
+    const sources = prepared.program.sources.map(source => {
+        const content = sourceContent.get(source.filename);
+        if (content === undefined)
+            throw new TypeError(`Preflighted iOS source '${source.filename}' lost its content.`);
+        return {
+            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(content).digest("hex")
+        };
+    });
+    const entryId = prepared.program.entryModule;
+    const entryArtifact = /** @type {string} */ (prepared.modulePaths.get(entryId));
+    const entryNamespace = `SemantifoldModule${moduleName(entryId)}`;
+    return {
+        entry: {
+            applicationArtifact: `${prepared.configuration.sourceRoot}/Application/App.swift`,
+            bridgeArtifact: `${prepared.configuration.sourceRoot}/Application/SemantifoldBridge.swift`,
+            generatedArtifact: entryArtifact,
+            generatedFunctionIdentity: `${entryNamespace}.semantifoldEntry`,
+            moduleId: entryId
+        },
+        modules,
+        schema: "SemantifoldIosSemanticProgram",
+        sources,
+        version: 1
+    };
+}
+/**
+ * Determines whether one closed semantic origin cites a source filename.
+ * @param {import("../semantic/types.js").SemanticOrigin} origin - Mapped origin.
+ * @param {string} filename - Original caller filename.
+ * @returns {boolean} Whether the source participates in the origin.
+ */
+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);
+}
+/**
+ * Groups renderer-recorded configuration ranges without scanning generated text.
+ * @param {ConfigurationArtifactSpan[]} spans - Causal artifact spans.
+ * @param {string} field - Normalized configuration field.
+ * @returns {{path: string, ranges: {end: number, start: number}[]}[]} Stable output citations.
+ */
+function configurationOutputCitations(spans, field) {
+    /** @type {Map<string, {end: number, start: number}[]>} */
+    const byPath = new Map();
+    for (const span of spans) {
+        if (span.field != field)
+            continue;
+        const ranges = byPath.get(span.path) ?? [];
+        ranges.push({ end: span.end, start: span.start });
+        byPath.set(span.path, ranges);
+    }
+    return [...byPath].map(([path, ranges]) => ({ path, ranges }));
+}
+/**
+ * Renders the shared capture runtime and mapped per-module semantic Swift.
+ * @param {ReturnType<typeof preflightIosApplication>} prepared - Fully preflighted application.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact[]} Ordered semantic artifacts.
+ */
+function renderSemanticArtifacts(prepared) {
+    const paths = prepared.modulePaths;
+    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 = [{
+            content: iosSwiftRuntime,
+            contentKind: "text",
+            mediaType: "text/x-swift",
+            ownership: "generated",
+            path: "Sources/Generated/SemantifoldRuntime.swift",
+            provenance: {
+                kind: "synthetic",
+                reason: "Shared iOS application output capture and exact Swift scalar support.",
+                relatedOrigins: []
+            },
+            role: "support"
+        }];
+    for (const module of prepared.modules) {
+        const moduleId = /** @type {string} */ (Reflect.get(module, "id"));
+        const filename = /** @type {string} */ (paths.get(moduleId));
+        const writer = new SourceWriter({
+            filename,
+            language: "swift",
+            module,
+            program: prepared.program,
+            programPaths: paths,
+            sources: prepared.sources
+        });
+        emitSemanticModule(writer, module, moduleId, moduleId == prepared.program.entryModule, declarations);
+        const mapping = finalizeMapping(writer.finish());
+        artifacts.push({
+            content: mapping.generated.content,
+            contentKind: "text",
+            mediaType: "text/x-swift",
+            ownership: "generated",
+            path: filename,
+            provenance: { kind: "text", mapping, sourceMap: toSourceMapV3(mapping), sourceMapFilename: `${filename}.map` },
+            role: "source"
+        });
+    }
+    return artifacts;
+}
+/**
+ * Produces all project paths referenced by the Xcode model.
+ * @param {ReturnType<typeof preflightIosApplication>} prepared - Prepared application.
+ * @returns {{appSources: string[], assets: string[], infoPlist: string, unitTest: string, uiTest: string, xcconfig: string}} Paths.
+ */
+function applicationArtifactPaths(prepared) {
+    const { productName: product, resourceRoot, sourceRoot } = prepared.configuration;
+    return {
+        appSources: [
+            `${sourceRoot}/Generated/SemantifoldRuntime.swift`,
+            ...prepared.modulePaths.values(),
+            `${sourceRoot}/Application/App.swift`,
+            `${sourceRoot}/Application/SemantifoldBridge.swift`,
+            `${sourceRoot}/Application/SemantifoldOutputView.swift`
+        ],
+        assets: [resourceRoot, ...prepared.assets.map(({ path }) => path)],
+        infoPlist: "Configuration/Info.plist",
+        unitTest: `Tests/${product}Tests.swift`,
+        uiTest: `UITests/${product}UITests.swift`,
+        xcconfig: "Configuration/Base.xcconfig"
+    };
+}
+/**
+ * Derives collision-checked uppercase 24-hex Xcode object IDs from normalized identities.
+ * @param {readonly string[]} identities - Complete ordered object identities.
+ * @param {(identity: string) => string} [digest] - Test-only digest seam; production uses built-in SHA-256.
+ * @returns {Map<string, string>} Object ID by full input identity.
+ */
+export function allocateXcodeObjectIds(identities, digest = identity => createHash("sha256").update(identity).digest("hex")) {
+    const result = new Map();
+    const fullIdentities = new Map();
+    for (const identity of identities) {
+        if (typeof identity != "string" || identity.length == 0 || result.has(identity)) {
+            throw new SemantifoldDiagnostic({ code: "XCODE_ID_COLLISION", language: "ios",
+                message: "Xcode object identities must be unique non-empty strings." });
+        }
+        const normalized = identity.normalize("NFC");
+        const fullDigest = digest(normalized);
+        if (!/^[0-9a-fA-F]{64}$/u.test(fullDigest)) {
+            throw new SemantifoldDiagnostic({ code: "XCODE_ID_COLLISION", language: "ios",
+                message: `Xcode object identity '${identity}' did not produce a full SHA-256 digest.` });
+        }
+        const objectId = fullDigest.slice(0, 24).toUpperCase();
+        const previous = fullIdentities.get(objectId);
+        if (previous !== undefined && previous != normalized) {
+            throw new SemantifoldDiagnostic({ code: "XCODE_ID_COLLISION", language: "ios",
+                message: `Xcode object identities '${previous}' and '${normalized}' collide at '${objectId}'.` });
+        }
+        fullIdentities.set(objectId, normalized);
+        result.set(identity, objectId);
+    }
+    return result;
+}
+/**
+ * Renders the smallest deterministic Xcode application/unit/UI-test project model.
+ * Platform execution remains deferred until the repository has a qualified Apple lane.
+ * @param {ReturnType<typeof preflightIosApplication>} prepared - Prepared application.
+ * @param {ReturnType<typeof applicationArtifactPaths>} paths - Complete owned paths.
+ * @returns {RenderedConfigurationText} Canonical LF project file and causal configuration spans.
+ */
+function renderPbxProject(prepared, paths) {
+    const configuration = prepared.configuration;
+    const product = configuration.productName;
+    const resourceRoot = configuration.resourceRoot;
+    const sourceRoot = configuration.sourceRoot;
+    const identities = [
+        "project", "group:main", "group:sources", "group:generated", "group:application", "group:configuration",
+        "group:tests", "group:uitests", "group:products", "target:app", "target:tests", "target:uitests",
+        "phase:app:sources", "phase:app:resources", "phase:app:frameworks", "phase:tests:sources", "phase:tests:resources",
+        "phase:tests:frameworks", "phase:uitests:sources", "phase:uitests:resources", "phase:uitests:frameworks",
+        "product:app", "product:tests", "product:uitests", "proxy:tests:app", "proxy:uitests:app",
+        "dependency:tests:app", "dependency:uitests:app",
+        "config-list:project", "config-list:app", "config-list:tests", "config-list:uitests",
+        "config:project:debug", "config:project:release", "config:app:debug", "config:app:release",
+        "config:tests:debug", "config:tests:release", "config:uitests:debug", "config:uitests:release",
+        `file:${paths.xcconfig}`, `file:${paths.infoPlist}`, `file:${resourceRoot}`,
+        `file:${paths.unitTest}`, `file:${paths.uiTest}`,
+        ...paths.appSources.flatMap(path => [`file:${path}`, `build:app:${path}`]),
+        `build:app:${resourceRoot}`, `build:tests:${paths.unitTest}`, `build:uitests:${paths.uiTest}`
+    ];
+    const ids = allocateXcodeObjectIds(identities);
+    /**
+     * Looks up one planned Xcode identity.
+     * @param {string} identity - Planned identity.
+     * @returns {string} Allocated object ID.
+     */
+    const id = identity => {
+        const value = ids.get(identity);
+        if (!value)
+            throw new TypeError(`Missing planned Xcode identity '${identity}'.`);
+        return value;
+    };
+    /** @type {Map<string, {identity: string, body: ConfigurationLine[]}[]>} */
+    const sections = new Map();
+    /**
+     * Adds an object to one PBX section.
+     * @param {string} section - PBX section.
+     * @param {string} identity - Object identity.
+     * @param {ConfigurationLine[]} body - Object fields.
+     */
+    const add = (section, identity, body) => {
+        const entries = sections.get(section) ?? [];
+        entries.push({ body, identity });
+        sections.set(section, entries);
+    };
+    /**
+     * Renders PBX list values.
+     * @param {string[]} values - PBX list values.
+     * @returns {string} Rendered list body.
+     */
+    const list = values => values.map(value => `\t\t\t\t${value},`).join("\n");
+    /**
+     * Produces a stable sorted copy.
+     * @param {string[]} values - Values to sort.
+     * @returns {string[]} Stable sorted copy.
+     */
+    const sorted = values => [...values].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+    for (const path of paths.appSources) {
+        add("PBXBuildFile", `build:app:${path}`, ["isa = PBXBuildFile;", `fileRef = ${id(`file:${path}`)};`]);
+        add("PBXFileReference", `file:${path}`, ["isa = PBXFileReference;", "lastKnownFileType = sourcecode.swift;",
+            ["path = ", ...pbxConfigurationPath(configuration, path), ";"], "sourceTree = SOURCE_ROOT;"]);
+    }
+    add("PBXBuildFile", `build:app:${resourceRoot}`, ["isa = PBXBuildFile;", `fileRef = ${id(`file:${resourceRoot}`)};`]);
+    add("PBXBuildFile", `build:tests:${paths.unitTest}`, ["isa = PBXBuildFile;", `fileRef = ${id(`file:${paths.unitTest}`)};`]);
+    add("PBXBuildFile", `build:uitests:${paths.uiTest}`, ["isa = PBXBuildFile;", `fileRef = ${id(`file:${paths.uiTest}`)};`]);
+    add("PBXContainerItemProxy", "proxy:tests:app", ["isa = PBXContainerItemProxy;", `containerPortal = ${id("project")};`,
+        "proxyType = 1;", `remoteGlobalIDString = ${id("target:app")};`,
+        ["remoteInfo = \"", configurationFragment("productName", product), "\";"]]);
+    add("PBXContainerItemProxy", "proxy:uitests:app", ["isa = PBXContainerItemProxy;", `containerPortal = ${id("project")};`,
+        "proxyType = 1;", `remoteGlobalIDString = ${id("target:app")};`,
+        ["remoteInfo = \"", configurationFragment("productName", product), "\";"]]);
+    add("PBXFileReference", `file:${paths.xcconfig}`, ["isa = PBXFileReference;", "lastKnownFileType = text.xcconfig;",
+        `path = ${pbxString(paths.xcconfig)};`, "sourceTree = SOURCE_ROOT;"]);
+    add("PBXFileReference", `file:${paths.infoPlist}`, ["isa = PBXFileReference;", "lastKnownFileType = text.plist.xml;",
+        `path = ${pbxString(paths.infoPlist)};`, "sourceTree = SOURCE_ROOT;"]);
+    add("PBXFileReference", `file:${resourceRoot}`, ["isa = PBXFileReference;", "lastKnownFileType = folder.assetcatalog;",
+        ["path = ", configurationFragment("resourceRoot", resourceRoot), ";"], "sourceTree = SOURCE_ROOT;"]);
+    add("PBXFileReference", `file:${paths.unitTest}`, ["isa = PBXFileReference;", "lastKnownFileType = sourcecode.swift;",
+        ["path = ", ...pbxConfigurationPath(configuration, paths.unitTest), ";"], "sourceTree = SOURCE_ROOT;"]);
+    add("PBXFileReference", `file:${paths.uiTest}`, ["isa = PBXFileReference;", "lastKnownFileType = sourcecode.swift;",
+        ["path = ", ...pbxConfigurationPath(configuration, paths.uiTest), ";"], "sourceTree = SOURCE_ROOT;"]);
+    add("PBXFileReference", "product:app", ["isa = PBXFileReference;", "explicitFileType = wrapper.application;", "includeInIndex = 0;",
+        ["path = \"", configurationFragment("productName", product), ".app\";"], "sourceTree = BUILT_PRODUCTS_DIR;"]);
+    add("PBXFileReference", "product:tests", ["isa = PBXFileReference;", "explicitFileType = wrapper.cfbundle;", "includeInIndex = 0;",
+        ["path = \"", configurationFragment("productName", product), "Tests.xctest\";"], "sourceTree = BUILT_PRODUCTS_DIR;"]);
+    add("PBXFileReference", "product:uitests", ["isa = PBXFileReference;", "explicitFileType = wrapper.cfbundle;", "includeInIndex = 0;",
+        ["path = \"", configurationFragment("productName", product), "UITests.xctest\";"], "sourceTree = BUILT_PRODUCTS_DIR;"]);
+    const generatedRefs = sorted(paths.appSources.filter(path => path.startsWith(`${sourceRoot}/Generated/`))).map(path => id(`file:${path}`));
+    const applicationRefs = sorted(paths.appSources.filter(path => path.startsWith(`${sourceRoot}/Application/`))).map(path => id(`file:${path}`));
+    add("PBXGroup", "group:main", ["isa = PBXGroup;", `children = (\n${list([
+            id("group:configuration"), id("group:sources"), id(`file:${resourceRoot}`), id("group:tests"), id("group:uitests"),
+            id("group:products")
+        ])}\n\t\t\t);`, "sourceTree = \"<group>\";"]);
+    add("PBXGroup", "group:sources", ["isa = PBXGroup;", `children = (\n${list([id("group:application"), id("group:generated")])}\n\t\t\t);`,
+        ["name = ", configurationFragment("sourceRoot", sourceRoot), ";"], "sourceTree = \"<group>\";"]);
+    add("PBXGroup", "group:generated", ["isa = PBXGroup;", `children = (\n${list(generatedRefs)}\n\t\t\t);`,
+        "name = Generated;", "sourceTree = \"<group>\";"]);
+    add("PBXGroup", "group:application", ["isa = PBXGroup;", `children = (\n${list(applicationRefs)}\n\t\t\t);`,
+        "name = Application;", "sourceTree = \"<group>\";"]);
+    add("PBXGroup", "group:configuration", ["isa = PBXGroup;", `children = (\n${list([id(`file:${paths.xcconfig}`), id(`file:${paths.infoPlist}`)])}\n\t\t\t);`,
+        "name = Configuration;", "sourceTree = \"<group>\";"]);
+    add("PBXGroup", "group:tests", ["isa = PBXGroup;", `children = (\n${list([id(`file:${paths.unitTest}`)])}\n\t\t\t);`,
+        "name = Tests;", "sourceTree = \"<group>\";"]);
+    add("PBXGroup", "group:uitests", ["isa = PBXGroup;", `children = (\n${list([id(`file:${paths.uiTest}`)])}\n\t\t\t);`,
+        "name = UITests;", "sourceTree = \"<group>\";"]);
+    add("PBXGroup", "group:products", ["isa = PBXGroup;", `children = (\n${list([id("product:app"), id("product:tests"), id("product:uitests")])}\n\t\t\t);`,
+        "name = Products;", "sourceTree = \"<group>\";"]);
+    addNativeTarget(add, id, configuration, "target:app", "", "com.apple.product-type.application", "product:app", "config-list:app", ["phase:app:sources", "phase:app:frameworks", "phase:app:resources"], []);
+    addNativeTarget(add, id, configuration, "target:tests", "Tests", "com.apple.product-type.bundle.unit-test", "product:tests", "config-list:tests", ["phase:tests:sources", "phase:tests:frameworks", "phase:tests:resources"], ["dependency:tests:app"]);
+    addNativeTarget(add, id, configuration, "target:uitests", "UITests", "com.apple.product-type.bundle.ui-testing", "product:uitests", "config-list:uitests", ["phase:uitests:sources", "phase:uitests:frameworks", "phase:uitests:resources"], ["dependency:uitests:app"]);
+    add("PBXProject", "project", ["isa = PBXProject;", "attributes = { BuildIndependentTargetsInParallel = YES; };",
+        `buildConfigurationList = ${id("config-list:project")};`, "developmentRegion = en;", "hasScannedForEncodings = 0;",
+        "knownRegions = ( en, Base, );", `mainGroup = ${id("group:main")};`, `productRefGroup = ${id("group:products")};`,
+        "projectDirPath = \"\";", "projectRoot = \"\";",
+        `targets = (\n${list([id("target:app"), id("target:tests"), id("target:uitests")])}\n\t\t\t);`]);
+    addBuildPhase(add, id, "PBXFrameworksBuildPhase", "phase:app:frameworks", []);
+    addBuildPhase(add, id, "PBXResourcesBuildPhase", "phase:app:resources", [`build:app:${resourceRoot}`]);
+    addBuildPhase(add, id, "PBXSourcesBuildPhase", "phase:app:sources", sorted(paths.appSources).map(path => `build:app:${path}`));
+    for (const target of ["tests", "uitests"]) {
+        addBuildPhase(add, id, "PBXFrameworksBuildPhase", `phase:${target}:frameworks`, []);
+        addBuildPhase(add, id, "PBXResourcesBuildPhase", `phase:${target}:resources`, []);
+    }
+    addBuildPhase(add, id, "PBXSourcesBuildPhase", "phase:tests:sources", [`build:tests:${paths.unitTest}`]);
+    addBuildPhase(add, id, "PBXSourcesBuildPhase", "phase:uitests:sources", [`build:uitests:${paths.uiTest}`]);
+    add("PBXTargetDependency", "dependency:tests:app", ["isa = PBXTargetDependency;", `target = ${id("target:app")};`,
+        `targetProxy = ${id("proxy:tests:app")};`]);
+    add("PBXTargetDependency", "dependency:uitests:app", ["isa = PBXTargetDependency;", `target = ${id("target:app")};`,
+        `targetProxy = ${id("proxy:uitests:app")};`]);
+    for (const owner of ["project", "app", "tests", "uitests"]) {
+        for (const variant of ["debug", "release"]) {
+            const settings = buildSettings(owner, variant, configuration, paths);
+            add("XCBuildConfiguration", `config:${owner}:${variant}`, ["isa = XCBuildConfiguration;",
+                `baseConfigurationReference = ${id(`file:${paths.xcconfig}`)};`, ["buildSettings = {\n", ...settings, "\n\t\t\t};"],
+                `name = ${variant == "debug" ? "Debug" : "Release"};`]);
+        }
+        add("XCConfigurationList", `config-list:${owner}`, ["isa = XCConfigurationList;",
+            `buildConfigurations = (\n${list([id(`config:${owner}:debug`), id(`config:${owner}:release`)])}\n\t\t\t);`,
+            "defaultConfigurationIsVisible = 0;", "defaultConfigurationName = Release;"]);
+    }
+    const order = ["PBXBuildFile", "PBXContainerItemProxy", "PBXFileReference", "PBXFrameworksBuildPhase", "PBXGroup",
+        "PBXNativeTarget", "PBXProject", "PBXResourcesBuildPhase", "PBXSourcesBuildPhase", "PBXTargetDependency",
+        "XCBuildConfiguration", "XCConfigurationList"];
+    const writer = new ConfigurationTextWriter();
+    writer.append("// !$*UTF8*$!\n{\n\tarchiveVersion = 1;\n\tclasses = {};\n\tobjectVersion = 56;\n\tobjects = {\n");
+    for (const section of order) {
+        const entries = (sections.get(section) ?? []).sort((left, right) => left.identity < right.identity ? -1 : 1);
+        writer.append(`\n/* Begin ${section} section */\n`);
+        for (const entry of entries) {
+            writer.append(`\t\t${id(entry.identity)} = {\n`);
+            for (const line of entry.body) {
+                writer.append("\t\t\t");
+                writer.append(line);
+                writer.append("\n");
+            }
+            writer.append("\t\t};\n");
+        }
+        writer.append(`/* End ${section} section */\n`);
+    }
+    writer.append(`\t};\n\trootObject = ${id("project")};\n}\n`);
+    return writer.finish();
+}
+/**
+ * Adds one native target object to the project model.
+ * @param {(section: string, identity: string, body: ConfigurationLine[]) => void} add - Object sink.
+ * @param {(identity: string) => string} id - ID lookup.
+ * @param {import("../semantic/types.js").IosApplicationConfiguration} configuration - Application configuration.
+ * @param {string} identity - Target identity.
+ * @param {string} nameSuffix - Target suffix after the product name.
+ * @param {string} productType - Product type.
+ * @param {string} productReference - Product reference identity.
+ * @param {string} configurationList - Configuration list identity.
+ * @param {string[]} phases - Phase identities.
+ * @param {string[]} dependencies - Dependency identities.
+ */
+function addNativeTarget(add, id, configuration, identity, nameSuffix, productType, productReference, configurationList, phases, dependencies) {
+    /**
+     * Renders target identity values.
+     * @param {string[]} values - Target identity values.
+     * @returns {string} Rendered target list.
+     */
+    const lines = values => values.map(value => `\t\t\t\t${id(value)},`).join("\n");
+    const name = ["\"", configurationFragment("productName", configuration.productName), `${nameSuffix}"`];
+    add("PBXNativeTarget", identity, ["isa = PBXNativeTarget;", `buildConfigurationList = ${id(configurationList)};`,
+        `buildPhases = (\n${lines(phases)}\n\t\t\t);`, "buildRules = ();", `dependencies = (\n${lines(dependencies)}\n\t\t\t);`,
+        ["name = ", ...name, ";"], ["productName = ", ...name, ";"], `productReference = ${id(productReference)};`,
+        `productType = ${pbxString(productType)};`]);
+}
+/**
+ * Adds one build phase to the project model.
+ * @param {(section: string, identity: string, body: ConfigurationLine[]) => void} add - Object sink.
+ * @param {(identity: string) => string} id - ID lookup.
+ * @param {string} section - Phase ISA.
+ * @param {string} identity - Phase identity.
+ * @param {string[]} files - Build-file identities.
+ */
+function addBuildPhase(add, id, section, identity, files) {
+    const lines = files.map(file => `\t\t\t\t${id(file)},`).join("\n");
+    add(section, identity, [`isa = ${section};`, "buildActionMask = 2147483647;", `files = (\n${lines}\n\t\t\t);`,
+        "runOnlyForDeploymentPostprocessing = 0;"]);
+}
+/**
+ * Renders sorted PBX build settings for one owner and variant.
+ * @param {string} owner - Configuration owner.
+ * @param {string} variant - Debug or release.
+ * @param {import("../semantic/types.js").IosApplicationConfiguration} configuration - Application configuration.
+ * @param {ReturnType<typeof applicationArtifactPaths>} paths - Planned paths.
+ * @returns {ConfigurationTextPart[]} Sorted PBX build settings.
+ */
+function buildSettings(owner, variant, configuration, paths) {
+    /** @type {Record<string, ConfigurationTextPart | ConfigurationTextPart[]>} */
+    const values = owner == "project" ? {
+        CODE_SIGNING_ALLOWED: "NO",
+        CODE_SIGNING_REQUIRED: "NO"
+    } : owner == "app" ? {
+        GENERATE_INFOPLIST_FILE: "NO",
+        INFOPLIST_FILE: pbxString(paths.infoPlist),
+        IPHONEOS_DEPLOYMENT_TARGET: configurationFragment("deploymentTarget", configuration.deploymentTarget),
+        PRODUCT_BUNDLE_IDENTIFIER: configurationFragment("bundleIdentifier", configuration.bundleIdentifier),
+        PRODUCT_MODULE_NAME: configurationFragment("moduleName", configuration.moduleName),
+        PRODUCT_NAME: configurationFragment("productName", configuration.productName),
+        SDKROOT: "iphoneos",
+        SUPPORTED_PLATFORMS: pbxString("iphoneos iphonesimulator"),
+        TARGETED_DEVICE_FAMILY: "1"
+    } : owner == "tests" ? {
+        BUNDLE_LOADER: pbxString("$(TEST_HOST)"),
+        PRODUCT_BUNDLE_IDENTIFIER: [configurationFragment("bundleIdentifier", configuration.bundleIdentifier), ".tests"],
+        PRODUCT_MODULE_NAME: [configurationFragment("moduleName", configuration.moduleName), "Tests"],
+        PRODUCT_NAME: "$(TARGET_NAME)",
+        TEST_HOST: ["\"$(BUILT_PRODUCTS_DIR)/", configurationFragment("productName", configuration.productName),
+            ".app/", configurationFragment("productName", configuration.productName), "\""]
+    } : {
+        PRODUCT_BUNDLE_IDENTIFIER: [configurationFragment("bundleIdentifier", configuration.bundleIdentifier), ".uitests"],
+        PRODUCT_MODULE_NAME: [configurationFragment("moduleName", configuration.moduleName), "UITests"],
+        PRODUCT_NAME: "$(TARGET_NAME)",
+        TEST_TARGET_NAME: configurationFragment("productName", configuration.productName)
+    };
+    if (variant == "release")
+        values.SWIFT_OPTIMIZATION_LEVEL = pbxString("-O");
+    /** @type {ConfigurationTextPart[]} */
+    const output = [];
+    for (const [index, key] of Object.keys(values).sort().entries()) {
+        const value = values[key];
+        if (index > 0)
+            output.push("\n");
+        output.push(`\t\t\t\t${key} = `);
+        output.push(...(Array.isArray(value) ? value : [value]));
+        output.push(";");
+    }
+    return output;
+}
+/**
+ * Quotes one PBX scalar.
+ * @param {string} value - PBX scalar.
+ * @returns {string} Safely quoted PBX scalar.
+ */
+function pbxString(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Renders a quoted PBX path while retaining causality for its configured component.
+ * @param {import("../semantic/types.js").IosApplicationConfiguration} configuration - Application configuration.
+ * @param {string} path - Planned artifact path.
+ * @returns {ConfigurationTextPart[]} Quoted PBX path fragments.
+ */
+function pbxConfigurationPath(configuration, path) {
+    if (path.startsWith(`${configuration.sourceRoot}/`)) {
+        return ["\"", configurationFragment("sourceRoot", configuration.sourceRoot), path.slice(configuration.sourceRoot.length), "\""];
+    }
+    if (path == configuration.resourceRoot) {
+        return ["\"", configurationFragment("resourceRoot", configuration.resourceRoot), "\""];
+    }
+    if (path == `Tests/${configuration.productName}Tests.swift`) {
+        return ["\"Tests/", configurationFragment("productName", configuration.productName), "Tests.swift\""];
+    }
+    if (path == `UITests/${configuration.productName}UITests.swift`) {
+        return ["\"UITests/", configurationFragment("productName", configuration.productName), "UITests.swift\""];
+    }
+    return [pbxString(path)];
+}
+/**
+ * Renders the shared scheme XML.
+ * @param {ReturnType<typeof preflightIosApplication>} prepared - Prepared application.
+ * @returns {RenderedConfigurationText} Shared scheme XML and causal configuration spans.
+ */
+function renderSharedScheme(prepared) {
+    const product = prepared.configuration.productName;
+    const appId = allocateXcodeObjectIds(["target:app"]).get("target:app");
+    const testId = allocateXcodeObjectIds(["target:tests"]).get("target:tests");
+    const uiTestId = allocateXcodeObjectIds(["target:uitests"]).get("target:uitests");
+    /**
+     * Renders one scheme buildable reference.
+     * @param {string} nameSuffix - Blueprint suffix after product name.
+     * @param {string} buildableSuffix - Product filename suffix.
+     * @param {string | undefined} id - Object ID.
+     * @returns {ConfigurationTextPart[]} XML reference.
+     */
+    const reference = (nameSuffix, buildableSuffix, id) => [`<BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "${id}"
+               BuildableName = "`, configurationFragment("productName", product), `${buildableSuffix}"
+               BlueprintName = "`, configurationFragment("productName", product), `${nameSuffix}"
+               ReferencedContainer = "container:`, configurationFragment("productName", product), `.xcodeproj">
+            </BuildableReference>`];
+    const writer = new ConfigurationTextWriter();
+    writer.append(`<?xml version="1.0" encoding="UTF-8"?>
+<Scheme version="1.7">
+   <BuildAction parallelizeBuildables="YES" buildImplicitDependencies="YES">
+      <BuildActionEntries>
+         <BuildActionEntry buildForTesting="YES" buildForRunning="YES" buildForProfiling="YES" buildForArchiving="YES" buildForAnalyzing="YES">
+            `);
+    writer.append(reference("", ".app", appId));
+    writer.append(`
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction buildConfiguration="Debug" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" shouldUseLaunchSchemeArgsEnv="YES">
+      <Testables>
+         <TestableReference skipped="NO">
+            `);
+    writer.append(reference("Tests", "Tests.xctest", testId));
+    writer.append(`
+         </TestableReference>
+         <TestableReference skipped="NO">
+            `);
+    writer.append(reference("UITests", "UITests.xctest", uiTestId));
+    writer.append(`
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction buildConfiguration="Debug" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" launchStyle="0" useCustomWorkingDirectory="NO" ignoresPersistentStateOnLaunch="NO" debugDocumentVersioning="YES" debugServiceExtension="internal" allowLocationSimulation="YES">
+      <BuildableProductRunnable runnableDebuggingMode="0">
+         `);
+    writer.append(reference("", ".app", appId));
+    writer.append(`
+      </BuildableProductRunnable>
+   </LaunchAction>
+   <ProfileAction buildConfiguration="Release" shouldUseLaunchSchemeArgsEnv="YES" savedToolIdentifier="" useCustomWorkingDirectory="NO" debugDocumentVersioning="YES">
+      <BuildableProductRunnable runnableDebuggingMode="0">
+         `);
+    writer.append(reference("", ".app", appId));
+    writer.append(`
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction buildConfiguration="Debug"/>
+   <ArchiveAction buildConfiguration="Release" revealArchiveInOrganizer="YES"/>
+</Scheme>
+`);
+    return writer.finish();
+}
+/**
+ * Renders the closed unsigned base configuration.
+ * @param {import("../semantic/types.js").IosApplicationConfiguration} configuration - Application configuration.
+ * @returns {RenderedConfigurationText} Base xcconfig and causal configuration spans.
+ */
+function renderBaseConfiguration(configuration) {
+    const writer = new ConfigurationTextWriter();
+    writer.append(`CODE_SIGNING_ALLOWED = NO
+CODE_SIGNING_REQUIRED = NO
+GENERATE_INFOPLIST_FILE = NO
+IPHONEOS_DEPLOYMENT_TARGET = `);
+    writer.append(configurationFragment("deploymentTarget", configuration.deploymentTarget));
+    writer.append("\nPRODUCT_BUNDLE_IDENTIFIER = ");
+    writer.append(configurationFragment("bundleIdentifier", configuration.bundleIdentifier));
+    writer.append("\nPRODUCT_MODULE_NAME = ");
+    writer.append(configurationFragment("moduleName", configuration.moduleName));
+    writer.append("\nPRODUCT_NAME = ");
+    writer.append(configurationFragment("productName", configuration.productName));
+    writer.append(`
+SDKROOT = iphoneos
+SUPPORTED_PLATFORMS = iphoneos iphonesimulator
+TARGETED_DEVICE_FAMILY = 1
+`);
+    return writer.finish();
+}
+/**
+ * Renders the allowlisted application property list.
+ * @param {import("../semantic/types.js").IosApplicationConfiguration} configuration - Application configuration.
+ * @returns {RenderedConfigurationText} Property-list XML and causal configuration spans.
+ */
+function renderInfoPlist(configuration) {
+    const writer = new ConfigurationTextWriter();
+    writer.append(`<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDisplayName</key>
+  <string>`);
+    writer.append(configurationFragment("displayName", xmlEscape(configuration.displayName)));
+    writer.append(`</string>
+  <key>CFBundleExecutable</key>
+  <string>$(EXECUTABLE_NAME)</string>
+  <key>CFBundleIdentifier</key>
+  <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>$(PRODUCT_NAME)</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+  <key>LSRequiresIPhoneOS</key>
+  <true/>
+  <key>UILaunchScreen</key>
+  <dict/>
+</dict>
+</plist>
+`);
+    return writer.finish();
+}
+/**
+ * Renders pure-logic XCTest source.
+ * @param {import("../semantic/types.js").IosApplicationConfiguration} configuration - Application configuration.
+ * @returns {RenderedConfigurationText} XCTest source and causal configuration spans.
+ */
+function renderUnitTests(configuration) {
+    const writer = new ConfigurationTextWriter();
+    writer.append("import XCTest\n@testable import ");
+    writer.append(configurationFragment("moduleName", configuration.moduleName));
+    writer.append("\n\nfinal class ");
+    writer.append(configurationFragment("productName", configuration.productName));
+    writer.append(`Tests: XCTestCase {
+  func testSemanticOutputIsDeterministic() {
+    XCTAssertEqual(SemantifoldBridge.run(), SemantifoldBridge.run())
+  }
+
+  func testOutputSinkPreservesScalarLines() {
+    let output = SemantifoldOutputSink()
+    output.write(Int64(7))
+    output.write(true)
+    output.write("é😀")
+    XCTAssertEqual(output.lines, ["7", "true", "é😀"])
+  }
+}
+`);
+    return writer.finish();
+}
+/**
+ * Renders the accessibility-route XCUI source.
+ * @param {import("../semantic/types.js").IosApplicationConfiguration} configuration - Application configuration.
+ * @returns {RenderedConfigurationText} XCUI source and causal configuration spans.
+ */
+function renderUiTests(configuration) {
+    const writer = new ConfigurationTextWriter();
+    writer.append("import XCTest\n\nfinal class ");
+    writer.append(configurationFragment("productName", configuration.productName));
+    writer.append(`UITests: XCTestCase {
+  func testOutputViewIsAccessible() {
+    let application = XCUIApplication()
+    application.launch()
+    XCTAssertTrue(application.staticTexts["semantifold-output"].waitForExistence(timeout: 5))
+  }
+}
+`);
+    return writer.finish();
+}
+/**
+ * Escapes XML text and attribute content.
+ * @param {string} value - XML text or attribute value.
+ * @returns {string} Escaped value.
+ */
+function xmlEscape(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
+        .replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+/**
+ * Creates one synthetic text artifact candidate.
+ * @param {string} path - Artifact path.
+ * @param {import("../semantic/types.js").GeneratedArtifactRole} role - Artifact role.
+ * @param {string} content - Exact LF content.
+ * @param {string} reason - Provenance reason.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Artifact candidate.
+ */
+function syntheticText(path, role, content, reason) {
+    return {
+        content,
+        contentKind: "text",
+        mediaType: path.endsWith(".swift") ? "text/x-swift" : path.endsWith(".json") ? "application/json" :
+            path.endsWith(".plist") || path.endsWith(".xcscheme") ? "application/xml" : "text/plain",
+        ownership: "generated",
+        path,
+        provenance: { kind: "synthetic", reason, relatedOrigins: [] },
+        role
+    };
+}
+/**
+ * Creates a synthetic artifact and transfers its renderer-owned configuration spans to the manifest ledger.
+ * @param {string} path - Artifact path.
+ * @param {import("../semantic/types.js").GeneratedArtifactRole} role - Artifact role.
+ * @param {RenderedConfigurationText} rendered - Rendered content and causal spans.
+ * @param {ConfigurationArtifactSpan[]} spans - Application-wide causal span ledger.
+ * @param {string} reason - Provenance reason.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Artifact candidate.
+ */
+function configuredSyntheticText(path, role, rendered, spans, reason) {
+    spans.push(...rendered.configurationSpans.map(span => ({ ...span, path })));
+    return syntheticText(path, role, rendered.content, reason);
+}
+/**
+ * Serializes recursively sorted canonical JSON with an LF.
+ * @param {unknown} value - JSON value.
+ * @returns {string} Canonical JSON with LF.
+ */
+function stringifyCanonicalJson(value) {
+    return `${JSON.stringify(sortJson(value), null, 2)}\n`;
+}
+/**
+ * Recursively sorts JSON object keys without reordering arrays.
+ * @param {unknown} value - JSON value.
+ * @returns {unknown} Recursively key-sorted JSON.
+ */
+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 and snapshots the strict baseline application configuration.
+ * Identity and deployment fields intentionally have no defaults without Apple-lane evidence.
+ * @param {unknown} candidate - Candidate configuration.
+ * @returns {import("../semantic/types.js").IosApplicationConfiguration} Normalized configuration.
+ */
+function normalizeConfiguration(candidate) {
+    if (!isPlainObject(candidate) || Object.keys(candidate).some(key => !configurationFields.has(key))) {
+        invalidConfiguration("iOS application configuration must be a closed plain object.");
+    }
+    const productName = candidate.productName;
+    const moduleName = candidate.moduleName;
+    const organizationPrefix = candidate.organizationPrefix;
+    const bundleIdentifier = candidate.bundleIdentifier;
+    const deploymentTarget = candidate.deploymentTarget;
+    const displayName = candidate.displayName;
+    if (typeof productName != "string" || !/^[A-Z][A-Za-z0-9]*$/u.test(productName)) {
+        invalidConfiguration("Product name must be an ASCII upper-camel identifier.");
+    }
+    if (typeof moduleName != "string" || !/^[A-Z][A-Za-z0-9]*$/u.test(moduleName)) {
+        invalidConfiguration("Module name must be an ASCII upper-camel identifier.");
+    }
+    if (typeof organizationPrefix != "string" || !isReverseDns(organizationPrefix, 2)) {
+        invalidConfiguration("Organization prefix must be a lowercase reverse-DNS identity with at least two segments.");
+    }
+    if (typeof bundleIdentifier != "string" || !isReverseDns(bundleIdentifier, 3) ||
+        !bundleIdentifier.startsWith(`${organizationPrefix}.`)) {
+        invalidConfiguration("Bundle identifier must extend the exact organization prefix as lowercase reverse DNS.");
+    }
+    if (typeof deploymentTarget != "string" || !/^[1-9][0-9]*\.(?:0|[1-9][0-9]*)$/u.test(deploymentTarget)) {
+        invalidConfiguration("Deployment target must be a caller-supplied canonical major.minor version.");
+    }
+    if (typeof displayName != "string" || displayName.length == 0 || displayName.trim() != displayName ||
+        [...displayName].length > 64 || !hasOnlyUnicodeScalars(displayName) || /\p{Cc}/u.test(displayName)) {
+        invalidConfiguration("Display name must be a non-empty single-line Unicode scalar string of at most 64 characters.");
+    }
+    const sourceRoot = candidate.sourceRoot ?? "Sources";
+    const resourceRoot = candidate.resourceRoot ?? "Assets.xcassets";
+    const lifecycle = candidate.lifecycle ?? "swiftui";
+    if (sourceRoot != "Sources" || !isSafeArtifactPath(sourceRoot))
+        invalidConfiguration("The supported source root is exactly 'Sources'.");
+    if (resourceRoot != "Assets.xcassets" || !isSafeArtifactPath(resourceRoot)) {
+        invalidConfiguration("The supported resource root is exactly 'Assets.xcassets'.");
+    }
+    if (lifecycle != "swiftui")
+        invalidConfiguration("The supported application lifecycle is exactly 'swiftui'.");
+    const infoPlist = candidate.infoPlist ?? {};
+    if (!isPlainObject(infoPlist) || Object.keys(infoPlist).length > 0) {
+        invalidConfiguration("The baseline caller Info.plist extension allowlist is empty.");
+    }
+    const permissions = emptyConfigurationSet(candidate.permissions, "permissions");
+    const entitlements = emptyConfigurationSet(candidate.entitlements, "entitlements");
+    const privacyDeclarations = emptyConfigurationSet(candidate.privacyDeclarations, "privacy declarations");
+    const capabilities = emptyConfigurationSet(candidate.capabilities, "capabilities");
+    return {
+        bundleIdentifier,
+        capabilities,
+        deploymentTarget,
+        displayName,
+        entitlements,
+        infoPlist: {},
+        lifecycle: "swiftui",
+        moduleName,
+        organizationPrefix,
+        permissions,
+        privacyDeclarations,
+        productName,
+        resourceRoot: "Assets.xcassets",
+        sourceRoot: "Sources"
+    };
+}
+/**
+ * Validates one optional closed empty configuration set.
+ * @param {unknown} candidate - Optional closed set.
+ * @param {string} label - Diagnostic label.
+ * @returns {never[]} Empty snapshot.
+ */
+function emptyConfigurationSet(candidate, label) {
+    if (candidate === undefined)
+        return [];
+    if (!isDenseArray(candidate) || candidate.length != 0)
+        invalidConfiguration(`The baseline ${label} set must be empty.`);
+    return [];
+}
+/**
+ * Tests one canonical lowercase reverse-DNS identity.
+ * @param {string} value - Candidate identity.
+ * @param {number} segments - Minimum segments.
+ * @returns {boolean} Validity.
+ */
+function isReverseDns(value, segments) {
+    const parts = value.split(".");
+    return parts.length >= segments && parts.every(part => /^[a-z][a-z0-9-]*$/u.test(part) && !part.endsWith("-"));
+}
+/**
+ * Validates, hashes, snapshots, and canonically sorts caller assets.
+ * @param {unknown} candidate - Candidate asset array.
+ * @param {string} resourceRoot - Exact resource root.
+ * @returns {import("../semantic/types.js").IosApplicationAssetInput[]} Normalized assets.
+ */
+function normalizeAssets(candidate, resourceRoot) {
+    if (candidate === undefined)
+        return [];
+    if (!isDenseArray(candidate))
+        invalidAsset("Application assets must be a dense array.");
+    /** @type {import("../semantic/types.js").IosApplicationAssetInput[]} */
+    const assets = [];
+    for (let index = 0; index < candidate.length; index += 1) {
+        const asset = candidate[index];
+        if (!isPlainObject(asset) || Object.keys(asset).some(key => !assetFields.has(key)) ||
+            Object.keys(asset).length != assetFields.size)
+            invalidAsset(`Asset ${index} must use the closed asset schema.`);
+        const path = asset.path;
+        const content = asset.content;
+        const mediaType = asset.mediaType;
+        const sha256 = asset.sha256;
+        if (!isSafeArtifactPath(path) || !path.startsWith(`${resourceRoot}/`) || path == `${resourceRoot}/Contents.json`) {
+            invalidAsset(`Asset ${index} requires a safe path below '${resourceRoot}'.`);
+        }
+        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, mediaType, path, sha256 });
+    }
+    assets.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+    return assets;
+}
+/**
+ * Creates an exact text or binary asset artifact.
+ * @param {import("../semantic/types.js").IosApplicationAssetInput} asset - Validated asset.
+ * @returns {import("../semantic/types.js").GeneratedSetArtifact} Artifact candidate.
+ */
+function assetArtifact(asset) {
+    if (typeof asset.content == "string")
+        return {
+            content: asset.content,
+            contentKind: "text",
+            mediaType: asset.mediaType,
+            ownership: "generated",
+            path: asset.path,
+            provenance: { kind: "synthetic", reason: `Exact caller-provided iOS asset (sha256:${asset.sha256}).`, relatedOrigins: [] },
+            role: "resource"
+        };
+    const content = new Uint8Array(asset.content);
+    return {
+        content,
+        contentKind: "binary",
+        mediaType: asset.mediaType,
+        ownership: "generated",
+        path: asset.path,
+        provenance: { kind: "bytes", mapping: createByteMapping({
+                byteLength: content.byteLength,
+                path: asset.path,
+                ranges: [{
+                        generated: { end: content.byteLength, start: 0 },
+                        origin: { kind: "synthetic", reason: `Exact caller-provided iOS asset (sha256:${asset.sha256}).`, relatedOrigins: [] },
+                        role: "asset"
+                    }]
+            }) },
+        role: "resource"
+    };
+}
+/**
+ * Throws a configuration diagnostic.
+ * @param {string} message - Failure detail.
+ * @returns {never} Always throws.
+ */
+function invalidConfiguration(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_CONFIGURATION", language: "ios", message });
+}
+/**
+ * Throws an asset diagnostic.
+ * @param {string} message - Failure detail.
+ * @returns {never} Always throws.
+ */
+function invalidAsset(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_ASSET", language: "ios", message });
+}
+/**
+ * Throws an application-path diagnostic.
+ * @param {string} message - Failure detail.
+ * @returns {never} Always throws.
+ */
+function invalidPath(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_APPLICATION_PATH", language: "ios", message });
+}
+/**
+ * Emits one backend-namespaced semantic module.
+ * @param {SourceWriter} writer - Source-aware generated Swift writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Prepared semantic module.
+ * @param {string} moduleId - Stable project module identity.
+ * @param {boolean} entry - Whether this module owns the semantic entry.
+ * @param {Map<string | undefined, {declaration: import("../semantic/types.js").FunctionDeclaration, moduleId: string}>} declarations - Resolved functions.
+ */
+function emitSemanticModule(writer, module, moduleId, entry, declarations) {
+    const namespace = `SemantifoldModule${moduleName(moduleId)}`;
+    writer.synthetic(`enum ${namespace} {\n`, "iOS semantic module namespace", [module], [""]);
+    module.functions.forEach((declaration, functionIndex) => {
+        const path = `/functions/${functionIndex}`;
+        writer.synthetic("  static ", "iOS namespaced function scaffold", [declaration], [path]);
+        writer.mapped("func", { mappingKind: "anchor", node: declaration, path });
+        writer.synthetic(" ", "declaration spacing", [declaration], [path]);
+        writer.mapped(declaration.name, { mappingKind: "exact", node: declaration, path, role: "name" });
+        writer.synthetic("(", "function parameter scaffold", [declaration], [path]);
+        declaration.parameters.forEach((parameter, parameterIndex) => {
+            const parameterPath = `${path}/parameters/${parameterIndex}`;
+            if (parameterIndex)
+                writer.synthetic(", ", "parameter separator", [parameter], [parameterPath]);
+            writer.synthetic("_ ", "unlabeled Swift parameter scaffold", [parameter], [parameterPath]);
+            writer.mapped(parameter.name, { mappingKind: "exact", node: parameter, path: parameterPath, role: "name" });
+            writer.synthetic(": ", "parameter annotation scaffold", [parameter], [parameterPath]);
+            writer.mapped(emitScalarType("swift", parameter.type), { mappingKind: "exact", node: parameter.type,
+                path: `${parameterPath}/type`, role: "type" });
+        });
+        writer.synthetic(", _ semantifold_output: SemantifoldOutputSink) -> ", "shared iOS output sink parameter", [declaration], [path]);
+        writer.mapped(emitScalarType("swift", declaration.returnType), { mappingKind: "exact", node: declaration.returnType,
+            path: `${path}/returnType`, role: "type" });
+        writer.synthetic(" {\n", "Swift function body scaffold", [declaration], [path]);
+        emitBlock(writer, declaration.body, "    ", `${path}/body`, declarations);
+        writer.synthetic("  }\n", "Swift function body scaffold", [declaration], [path]);
+    });
+    if (entry) {
+        writer.synthetic("  static func semantifoldEntry() -> [String] {\n", "iOS semantic entry scaffold", [module.entryPoint], ["/entryPoint"]);
+        writer.synthetic("    let semantifold_output = SemantifoldOutputSink()\n", "shared iOS output sink allocation", [module.entryPoint], ["/entryPoint"]);
+        emitBlock(writer, module.entryPoint.body, "    ", "/entryPoint/body", declarations);
+        writer.synthetic("    return semantifold_output.lines\n", "iOS semantic output return", [module.entryPoint], ["/entryPoint"]);
+        writer.synthetic("  }\n", "iOS semantic entry scaffold", [module.entryPoint], ["/entryPoint"]);
+    }
+    writer.synthetic("}\n", "iOS semantic module namespace", [module], [""]);
+}
+/**
+ * Emits a validated ordered semantic block.
+ * @param {SourceWriter} writer - Source writer.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {string} indent - Current indentation.
+ * @param {string} path - Block occurrence path.
+ * @param {Map<string | undefined, {declaration: import("../semantic/types.js").FunctionDeclaration, moduleId: string}>} declarations - Resolved functions.
+ */
+function emitBlock(writer, block, indent, path, declarations) {
+    block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`, declarations));
+}
+/**
+ * Emits one Swift statement through the shared capture sink.
+ * @param {SourceWriter} writer - Source writer.
+ * @param {import("../semantic/types.js").Statement} statement - Validated statement.
+ * @param {string} indent - Current indentation.
+ * @param {string} path - Statement occurrence path.
+ * @param {Map<string | undefined, {declaration: import("../semantic/types.js").FunctionDeclaration, moduleId: string}>} declarations - Resolved functions.
+ */
+function emitStatement(writer, statement, indent, path, declarations) {
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    if (statement.kind == "LocalDeclaration") {
+        writer.mapped(statement.mutable ? "var" : "let", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic(" ", "declaration spacing", [statement], [path]);
+        writer.mapped(statement.name, { mappingKind: "exact", node: statement, path, role: "name" });
+        writer.synthetic(": ", "local annotation scaffold", [statement], [path]);
+        writer.mapped(emitScalarType("swift", statement.type), { mappingKind: "exact", node: statement.type,
+            path: `${path}/type`, role: "type" });
+        writer.synthetic(" = ", "assignment spacing", [statement], [path]);
+        emitExpression(writer, statement.initializer, `${path}/initializer`, declarations);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        if (statement.mutable)
+            writer.synthetic(`${indent}semantifold_keep_mutable(&${statement.name})\n`, "Swift mutable-local warning marker", [statement], [path]);
+        return;
+    }
+    if (statement.kind == "AssignmentStatement") {
+        writer.mapped(statement.target.name, { mappingKind: "exact", node: statement.target, path: `${path}/target`, role: "name" });
+        writer.synthetic(" = ", "assignment spacing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, declarations);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    if (statement.kind == "ReturnStatement") {
+        if (!statement.expression)
+            throw new TypeError("iOS Swift bare return reached emission.");
+        writer.mapped("return", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic(" ", "return spacing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, declarations);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    if (statement.kind == "PrintStatement") {
+        writer.synthetic("semantifold_output.write(", "iOS output capture", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, declarations);
+        writer.synthetic(")\n", "iOS output capture", [statement], [path]);
+        return;
+    }
+    if (statement.kind != "IfStatement")
+        throw new TypeError("Unsupported iOS Swift statement reached emission.");
+    writer.mapped("if", { mappingKind: "anchor", node: statement, path });
+    writer.synthetic(" ", "conditional spacing", [statement], [path]);
+    emitExpression(writer, statement.condition, `${path}/condition`, declarations);
+    writer.synthetic(" {\n", "Swift conditional scaffold", [statement.consequent], [`${path}/consequent`]);
+    emitBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`, declarations);
+    writer.synthetic(`${indent}}`, "Swift conditional scaffold", [statement.consequent], [`${path}/consequent`]);
+    if (statement.alternate) {
+        writer.synthetic(" else {\n", "Swift alternate scaffold", [statement.alternate], [`${path}/alternate`]);
+        emitBlock(writer, statement.alternate, `${indent}  `, `${path}/alternate`, declarations);
+        writer.synthetic(`${indent}}`, "Swift alternate scaffold", [statement.alternate], [`${path}/alternate`]);
+    }
+    writer.synthetic("\n", "line break", [statement], [path]);
+}
+/**
+ * Emits one validated Tasks 001-004 expression and threads the shared sink through calls.
+ * @param {SourceWriter} writer - Source writer.
+ * @param {import("../semantic/types.js").Expression} expression - Semantic expression.
+ * @param {string} path - Expression occurrence path.
+ * @param {Map<string | undefined, {declaration: import("../semantic/types.js").FunctionDeclaration, moduleId: string}>} declarations - Resolved functions.
+ */
+function emitExpression(writer, expression, path, declarations) {
+    if (expression.kind == "IdentifierExpression") {
+        writer.mapped(expression.name, { mappingKind: "exact", node: expression, path, role: "name" });
+        return;
+    }
+    if (expression.kind == "IntegerLiteral") {
+        writer.mapped(String(expression.value), { mappingKind: "exact", node: expression, path, role: "literal" });
+        return;
+    }
+    if (expression.kind == "BooleanLiteral") {
+        writer.mapped(expression.value ? "true" : "false", { mappingKind: "exact", node: expression, path, role: "literal" });
+        return;
+    }
+    if (expression.kind == "StringLiteral") {
+        writer.mapped(emitStringLiteral("swift", expression.value), { mappingKind: "exact", node: expression, path, role: "literal" });
+        return;
+    }
+    if (expression.kind == "CallExpression") {
+        const resolved = declarations.get(expression.resolution?.declarationId);
+        if (!resolved)
+            throw new TypeError(`Unknown validated iOS function '${expression.resolution?.declarationId}'.`);
+        writer.mapped(`SemantifoldModule${moduleName(resolved.moduleId)}.${resolved.declaration.name}`, {
+            mappingKind: "exact", name: expression.callee, node: expression, path, role: "callee"
+        });
+        writer.synthetic("(", "iOS semantic function call", [expression], [path]);
+        expression.arguments.forEach((argument, index) => {
+            if (index)
+                writer.synthetic(", ", "argument separator", [expression], [path]);
+            emitExpression(writer, argument, `${path}/arguments/${index}`, declarations);
+        });
+        writer.synthetic(", semantifold_output)", "shared iOS output sink argument", [expression], [path]);
+        return;
+    }
+    if (expression.kind == "UnaryExpression") {
+        writer.mapped("(", { mappingKind: "anchor", node: expression, path });
+        writer.mapped(unaryOperations[expression.operation], { mappingKind: "exact", node: expression, path, role: "operator" });
+        emitExpression(writer, expression.operand, `${path}/operand`, declarations);
+        writer.mapped(")", { mappingKind: "anchor", node: expression, path });
+        return;
+    }
+    if (expression.kind != "BinaryExpression")
+        throw new TypeError("Unsupported iOS Swift expression reached emission.");
+    if (expression.operation == "StringEqual" || expression.operation == "StringNotEqual") {
+        writer.mapped(expression.operation == "StringEqual" ? "semantifold_string_equal" : "semantifold_string_not_equal", { mappingKind: "exact", node: expression, path, role: "operator" });
+        writer.synthetic("(", "Swift scalar-equality helper call", [expression], [path]);
+        emitExpression(writer, expression.left, `${path}/left`, declarations);
+        writer.synthetic(", ", "Swift scalar-equality argument separator", [expression], [path]);
+        emitExpression(writer, expression.right, `${path}/right`, declarations);
+        writer.synthetic(")", "Swift scalar-equality helper call", [expression], [path]);
+        return;
+    }
+    writer.mapped("(", { mappingKind: "anchor", node: expression, path });
+    emitExpression(writer, expression.left, `${path}/left`, declarations);
+    writer.synthetic(" ", "operator spacing", [expression], [path]);
+    writer.mapped(binaryOperations[expression.operation], { mappingKind: "exact", node: expression, path, role: "operator" });
+    writer.synthetic(" ", "operator spacing", [expression], [path]);
+    emitExpression(writer, expression.right, `${path}/right`, declarations);
+    writer.mapped(")", { mappingKind: "anchor", node: expression, path });
+}
+/**
+ * Converts a validated logical module identity to its Swift namespace suffix.
+ * @param {string} id - Logical module identity.
+ * @returns {string} Deterministic Swift namespace suffix and filename.
+ */
+function moduleName(id) {
+    return id.split(/[._-]+/u).map(part => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
+}
+/**
+ * Clones and normalizes one provenance-bearing semantic module into a one-module project.
+ * @param {import("../semantic/types.js").SemanticModule | undefined} candidate - Candidate module.
+ * @returns {import("../semantic/types.js").SemanticProgram} Normalized program.
+ */
+function normalizeSingleModule(candidate) {
+    if (!isPlainObject(candidate))
+        unsupportedCapability("ios", "missing or invalid module", undefined);
+    const module = structuredClone(candidate);
+    const provenanceSources = module.provenance?.sources;
+    if (!Array.isArray(provenanceSources) || provenanceSources.length != 1 || provenanceSources[0].content === null ||
+        provenanceSources[0].filename != module.location?.filename || typeof provenanceSources[0].language != "string") {
+        unsupportedCapability("ios", "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 = /** @type {import("../semantic/types.js").SemanticProgramModule} */ ({
+        ...module,
+        exports,
+        id: "main",
+        imports: [],
+        sourceFilename: provenanceSources[0].filename
+    });
+    return {
+        entryModule: "main",
+        kind: "Program",
+        modules: [programModule],
+        sources: structuredClone(provenanceSources)
+    };
+}
+/**
+ * Creates a normalized export for a single-module declaration without inventing a source range.
+ * @param {{id?: string, location: import("../semantic/types.js").SourceLocation, name: string}} declaration - Exported declaration.
+ * @param {import("../semantic/types.js").SemanticDeclarationKind} symbolKind - Declaration namespace.
+ * @returns {import("../semantic/types.js").SemanticExport} Synthetic project edge anchored to its declaration.
+ */
+function applicationExport(declaration, symbolKind) {
+    return {
+        declarationId: /** @type {string} */ (declaration.id),
+        exportedName: declaration.name,
+        kind: "Export",
+        location: declaration.location,
+        symbolKind
+    };
+}
+/**
+ * Prefixes declaration identities and typed references in a cloned single module.
+ * @param {import("../semantic/types.js").SemanticModule} module - Cloned module.
+ * @param {string} moduleId - Normalized 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 declaration identities in one cloned semantic subtree.
+     * @param {unknown} value - Candidate semantic subtree.
+     * @returns {void}
+     */
+    function visit(value) {
+        if (!value || typeof value != "object" || seen.has(value))
+            return;
+        seen.add(value);
+        if (!Array.isArray(value)) {
+            for (const [key, nested] of Object.entries(value)) {
+                if (identityFields.has(key) && typeof nested == "string" && replacements.has(nested)) {
+                    Reflect.set(value, key, replacements.get(nested));
+                }
+                else
+                    visit(nested);
+            }
+        }
+        else
+            for (const nested of value)
+                visit(nested);
+    }
+    visit(module);
+}
+/**
+ * Tests for a plain request object.
+ * @param {unknown} value - Candidate request.
+ * @returns {value is Record<string, unknown>} Whether it is a plain object.
+ */
+function isPlainObject(value) {
+    return Boolean(value) && typeof value == "object" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ios.js","sourceRoot":"","sources":["../../../src/backends/ios.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AACtC,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAA;AACxC,OAAO,EAAC,gCAAgC,EAAE,kBAAkB,EAAC,MAAM,qBAAqB,CAAA;AACxF,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAC,qBAAqB,EAAE,qBAAqB,EAAC,MAAM,kBAAkB,CAAA;AAC7E,OAAO,EAAC,eAAe,EAAE,aAAa,EAAC,MAAM,eAAe,CAAA;AAC5D,OAAO,EAAC,qBAAqB,EAAC,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EAAC,wBAAwB,EAAC,MAAM,cAAc,CAAA;AACrD,OAAO,EAAC,cAAc,EAAE,iBAAiB,EAAC,MAAM,cAAc,CAAA;AAC9D,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAA;AAExC,6EAA6E;AAC7E,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACjC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAC3H,CAAC,CAAA;AACF,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC;IAClC,kBAAkB,EAAE,cAAc,EAAE,kBAAkB,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW;IAC/G,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,qBAAqB,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY;CACtH,CAAC,CAAA;AACF,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAA;AACvE,MAAM,gBAAgB,GAAG,OAAO,CAAA;AAChC,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC;IACzC,kBAAkB;IAClB,kBAAkB;IAClB,aAAa;IACb,gBAAgB;IAChB,UAAU;CACX,CAAC,CAAA;AACF,MAAM,gBAAgB,GAAG,uEAAuE,CAAA;AAChG,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC;IACrC,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,IAAI;IAClB,eAAe,EAAE,IAAI;IACrB,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,GAAG;IACf,YAAY,EAAE,IAAI;IAClB,kBAAkB,EAAE,GAAG;IACvB,yBAAyB,EAAE,IAAI;IAC/B,eAAe,EAAE,GAAG;IACpB,sBAAsB,EAAE,IAAI;IAC5B,eAAe,EAAE,GAAG;IACpB,eAAe,EAAE,IAAI;IACrB,eAAe,EAAE,GAAG;IACpB,YAAY,EAAE,GAAG;IACjB,WAAW,EAAE,IAAI;IACjB,cAAc,EAAE,IAAI;CACrB,CAAC,CAAA;AACF,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC,EAAC,UAAU,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,EAAC,CAAC,CAAA;AAC5E,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BvB,CAAA;AAED,wEAAwE;AACxE,sEAAsE;AACtE,6EAA6E;AAC7E,+EAA+E;AAC/E,sGAAsG;AACtG,qGAAqG;AAErG,2EAA2E;AAC3E,MAAM,uBAAuB;IAC3B;QACE,IAAI,CAAC,OAAO,GAAG,EAAE,CAAA;QACjB,kCAAkC;QAClC,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAA;IAC9B,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK;QACV,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;QAEpD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,OAAO,IAAI,IAAI,QAAQ,EAAE,CAAC;gBAC5B,IAAI,CAAC,OAAO,IAAI,IAAI,CAAA;YACtB,CAAC;iBAAM,CAAC;gBACN,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAA;gBAEjC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAA;gBAC5B,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAC,CAAC,CAAA;YACpF,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,MAAM;QACJ,OAAO,EAAC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAC,CAAA;IAC7E,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,qBAAqB,CAAC,KAAK,EAAE,OAAO;IAC3C,OAAO,EAAC,OAAO,EAAE,KAAK,EAAC,CAAA;AACzB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAK;IAC3C,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QAC7E,MAAM,IAAI,qBAAqB,CAAC;YAC9B,IAAI,EAAE,2BAA2B;YACjC,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,6EAA6E;SACvF,CAAC,CAAA;IACJ,CAAC;IACD,MAAM,aAAa,GAAG,sBAAsB,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;IACjE,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,qBAAqB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IACpE,MAAM,QAAQ,GAAG,wBAAwB,CAAC;QACxC,eAAe,EAAE,OAAO;QACxB,kBAAkB,EAAE,KAAK;QACzB,OAAO;QACP,eAAe,EAAE,kBAAkB;KACpC,CAAC,CAAA;IACF,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACzD,qBAAqB,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACjD,GAAG,aAAa,CAAC,UAAU,cAAc,UAAU,CAAC,qBAAqB,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,QAAQ;KAC/G,CAAC,CAAC,CAAA;IACH,MAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;IACxE,MAAM,QAAQ,GAAG,gCAAgC,CAAC;QAChD,GAAG,aAAa,CAAC,UAAU,qCAAqC;QAChE,GAAG,WAAW,CAAC,MAAM,EAAE;QACvB,GAAG,aAAa,CAAC,YAAY,gBAAgB;QAC7C,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC;KAChC,CAAC,CAAA;IAEF,IAAI,QAAQ;QAAE,WAAW,CAAC,8BAA8B,QAAQ,CAAC,IAAI,WAAW,QAAQ,CAAC,IAAI,YAAY,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IAE9J,OAAO,EAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAC,CAAA;AAC1D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAK;IAC1C,MAAM,QAAQ,GAAG,uBAAuB,CAAC,KAAK,CAAC,CAAA;IAC/C,MAAM,iBAAiB,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAA;IAC3D,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,QAAQ,CAAC,CAAA;IAC3D,MAAM,OAAO,GAAG,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAA;IAC5D,MAAM,MAAM,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAA;IAC3C,MAAM,iBAAiB,GAAG,uBAAuB,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAA;IACzE,MAAM,SAAS,GAAG,eAAe,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAA;IACzD,MAAM,SAAS,GAAG,eAAe,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAA;IACzD,MAAM,OAAO,GAAG,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAA;IACrD,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAA;IAC5C,MAAM,cAAc,GAAG,oBAAoB,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAA;IACrF,MAAM,GAAG,GAAG;;;;;;;;;;CAUb,CAAA;IACC,MAAM,MAAM,GAAG;;aAEJ,cAAc;;;CAG1B,CAAA;IACC,MAAM,IAAI,GAAG;;;;;;;;;;CAUd,CAAA;IACC,MAAM,OAAO,GAAG,aAAa,CAAC,WAAW,CAAA;IACzC,0CAA0C;IAC1C,MAAM,kBAAkB,GAAG,EAAE,CAAA;IAC7B,MAAM,SAAS,GAAG;QAChB,uBAAuB,CAAC,GAAG,OAAO,4BAA4B,EAAE,UAAU,EAAE,OAAO,EACjF,kBAAkB,EAClB,kDAAkD,CAAC;QACrD,uBAAuB,CAAC,GAAG,OAAO,qCAAqC,OAAO,WAAW,EAAE,SAAS,EAClG,MAAM,EAAE,kBAAkB,EAAE,iDAAiD,CAAC;QAChF,uBAAuB,CAAC,6BAA6B,EAAE,SAAS,EAAE,iBAAiB,EAAE,kBAAkB,EACrG,0CAA0C,CAAC;QAC7C,uBAAuB,CAAC,0BAA0B,EAAE,SAAS,EAAE,SAAS,EAAE,kBAAkB,EAC1F,4CAA4C,CAAC;QAC/C,GAAG,iBAAiB;QACpB,aAAa,CAAC,+BAA+B,EAAE,OAAO,EAAE,GAAG,EAAE,0CAA0C,CAAC;QACxG,aAAa,CAAC,6CAA6C,EAAE,SAAS,EAAE,MAAM,EAC5E,sDAAsD,CAAC;QACzD,aAAa,CAAC,iDAAiD,EAAE,SAAS,EAAE,IAAI,EAC9E,iEAAiE,CAAC;QACpE,aAAa,CAAC,+BAA+B,EAAE,UAAU,EAAE,sBAAsB,CAAC;YAChF,IAAI,EAAE,EAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,EAAC;SAC1C,CAAC,EAAE,kEAAkE,CAAC;QACvE,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC;QACrC,uBAAuB,CAAC,SAAS,OAAO,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,kBAAkB,EAC7F,iDAAiD,CAAC;QACpD,uBAAuB,CAAC,WAAW,OAAO,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,kBAAkB,EAC/F,iDAAiD,CAAC;KACrD,CAAA;IACD,MAAM,YAAY,GAAG,0BAA0B,CAAA;IAE/C,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,UAAU,EACnD,qBAAqB,CAAC,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,kBAAkB,CAAC,EAC5E,0DAA0D,CAAC,CAAC,CAAA;IAE9D,OAAO;QACL,SAAS;QACT,QAAQ,EAAE,EAAC,mBAAmB,EAAE,YAAY,EAAE,qBAAqB,EAAE,UAAU,EAAC;QAChF,MAAM,EAAE,KAAK;KACd,CAAA;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,qBAAqB,CAAC,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,kBAAkB;IAClF,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjE,MAAM,iBAAiB,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,IAAI,MAAM,CAAC,CAAA;IAC1F,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAA;IAE5C,OAAO,sBAAsB,CAAC;QAC5B,aAAa;QACb,SAAS,EAAE,EAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,gBAAgB,EAAC;QAC3D,SAAS,EAAE;YACT,oBAAoB;YACpB,UAAU,EAAE,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC;SAC/D;QACD,oBAAoB,EAAE;YACpB,QAAQ,EAAE,EAAC,MAAM,EAAE,UAAU,EAAC;YAC9B,YAAY,EAAE,EAAC,MAAM,EAAE,UAAU,EAAC;YAClC,SAAS,EAAE,EAAC,MAAM,EAAE,UAAU,EAAC;YAC/B,MAAM,EAAE,EAAC,MAAM,EAAE,UAAU,EAAC;YAC5B,KAAK,EAAE,EAAC,MAAM,EAAE,UAAU,EAAC;YAC3B,MAAM,EAAE,EAAC,MAAM,EAAE,UAAU,EAAC;YAC5B,cAAc,EAAE,EAAC,MAAM,EAAE,UAAU,EAAC;SACrC;QACD,UAAU,EAAE;YACV,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBACpC,WAAW,EAAE,OAAO,KAAK,CAAC,OAAO,IAAI,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ;gBACjE,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,KAAK,CAAC,MAAM;aACrB,CAAC,CAAC;YACH,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAC7D,KAAK;gBACL,eAAe,EAAE,kBAAkB,KAAK,EAAE;gBAC1C,OAAO,EAAE,4BAA4B,CAAC,kBAAkB,EAAE,KAAK,CAAC;aACjE,CAAC,CAAC;YACH,eAAe,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAC/C,SAAS,EAAE,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,IAAI,MAAM;oBAChF,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAC,MAAM,EAAC,EAAE,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;qBACvG,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC;gBACxB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAC,CAAC;gBACrE,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aAClE,CAAC,CAAC;YACH,oBAAoB,EAAE;gBACpB,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,IAAI,WAAW,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;qBACvG,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC;gBACxB,YAAY;aACb;SACF;QACD,MAAM,EAAE,uBAAuB;QAC/B,eAAe,EAAE,uBAAuB,CAAC,QAAQ,CAAC;QAClD,MAAM,EAAE,KAAK;QACb,OAAO,EAAE,CAAC;KACX,CAAC,CAAA;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,QAAQ;IACvC,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IAC9F,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAChG,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;QACpD,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,CAAA;QACpB,MAAM,IAAI,GAAG,qBAAqB,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAA;QACjE,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,QAAQ,IAAI,MAAM,CAAC,cAAc,CAAC,CAAA;QACtG,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;QAExD,IAAI,CAAC,MAAM,IAAI,OAAO,KAAK,SAAS;YAAE,MAAM,IAAI,SAAS,CAAC,2BAA2B,EAAE,8BAA8B,CAAC,CAAA;QACtH,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAC,QAAQ,EAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;aAC5E,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,qBAAqB,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAEpH,OAAO;YACL,YAAY;YACZ,kBAAkB,EAAE,CAAC,IAAI,CAAC;YAC1B,EAAE;YACF,SAAS,EAAE,oBAAoB,UAAU,CAAC,EAAE,CAAC,EAAE;YAC/C,MAAM,EAAE;gBACN,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,EAAE,EAAE,MAAM,CAAC,EAAE;gBACb,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aAC3D;SACF,CAAA;IACH,CAAC,CAAC,CAAA;IACF,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;QACpD,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QAElD,IAAI,OAAO,KAAK,SAAS;YAAE,MAAM,IAAI,SAAS,CAAC,2BAA2B,MAAM,CAAC,QAAQ,qBAAqB,CAAC,CAAA;QAE/G,OAAO;YACL,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,EAAE,EAAE,MAAM,CAAC,EAAE;YACb,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YAChG,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,aAAa;YAC5C,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;SAC3D,CAAA;IACH,CAAC,CAAC,CAAA;IACF,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAA;IAC5C,MAAM,aAAa,GAAG,qBAAqB,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAC/E,MAAM,cAAc,GAAG,oBAAoB,UAAU,CAAC,OAAO,CAAC,EAAE,CAAA;IAEhE,OAAO;QACL,KAAK,EAAE;YACL,mBAAmB,EAAE,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,wBAAwB;YACjF,cAAc,EAAE,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,sCAAsC;YAC1F,iBAAiB,EAAE,aAAa;YAChC,yBAAyB,EAAE,GAAG,cAAc,mBAAmB;YAC/D,QAAQ,EAAE,OAAO;SAClB;QACD,OAAO;QACP,MAAM,EAAE,+BAA+B;QACvC,OAAO;QACP,OAAO,EAAE,CAAC;KACX,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,wBAAwB,CAAC,MAAM,EAAE,QAAQ;IAChD,IAAI,MAAM,CAAC,IAAI,IAAI,QAAQ;QAAE,OAAO,MAAM,CAAC,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAA;IACxE,IAAI,MAAM,CAAC,IAAI,IAAI,SAAS;QAAE,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAC,QAAQ,EAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,CAAA;IAEvG,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAC,QAAQ,EAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,CAAA;AAClF,CAAC;AAED;;;;;GAKG;AACH,SAAS,4BAA4B,CAAC,KAAK,EAAE,KAAK;IAChD,0DAA0D;IAC1D,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,CAAA;IAExB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,KAAK,IAAI,KAAK;YAAE,SAAQ;QACjC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAA;QAE1C,MAAM,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAC,CAAC,CAAA;QAC/C,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAC/B,CAAC;IAED,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAC,IAAI,EAAE,MAAM,EAAC,CAAC,CAAC,CAAA;AAC9D,CAAC;AAED;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,QAAQ;IACvC,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,CAAA;IAClC,MAAM,YAAY,GAAG,IAAI,GAAG,EAAE,CAAA;IAE9B,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;QACtC,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,SAAS;YAAE,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,EAAE;gBAC3E,WAAW;gBACX,QAAQ,EAAE,qBAAqB,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;aAC5D,CAAC,CAAA;IACJ,CAAC;IACD,oEAAoE;IACpE,MAAM,SAAS,GAAG,CAAC;YACjB,OAAO,EAAE,eAAe;YACxB,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE,cAAc;YACzB,SAAS,EAAE,WAAW;YACtB,IAAI,EAAE,4CAA4C;YAClD,UAAU,EAAE;gBACV,IAAI,EAAE,WAAW;gBACjB,MAAM,EAAE,uEAAuE;gBAC/E,cAAc,EAAE,EAAE;aACnB;YACD,IAAI,EAAE,SAAS;SAChB,CAAC,CAAA;IAEF,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;QACtC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAA;QAClE,MAAM,QAAQ,GAAG,qBAAqB,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAA;QAC5D,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC;YAC9B,QAAQ;YACR,QAAQ,EAAE,OAAO;YACjB,MAAM;YACN,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,YAAY,EAAE,KAAK;YACnB,OAAO,EAAE,QAAQ,CAAC,OAAO;SAC1B,CAAC,CAAA;QAEF,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,YAAY,CAAC,CAAA;QACpG,MAAM,OAAO,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAA;QAEhD,SAAS,CAAC,IAAI,CAAC;YACb,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,OAAO;YAClC,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE,cAAc;YACzB,SAAS,EAAE,WAAW;YACtB,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,iBAAiB,EAAE,GAAG,QAAQ,MAAM,EAAC;YAC5G,IAAI,EAAE,QAAQ;SACf,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAED;;;;GAIG;AACH,SAAS,wBAAwB,CAAC,QAAQ;IACxC,MAAM,EAAC,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAC,GAAG,QAAQ,CAAC,aAAa,CAAA;IAE/E,OAAO;QACL,UAAU,EAAE;YACV,GAAG,UAAU,qCAAqC;YAClD,GAAG,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE;YAChC,GAAG,UAAU,wBAAwB;YACrC,GAAG,UAAU,sCAAsC;YACnD,GAAG,UAAU,0CAA0C;SACxD;QACD,MAAM,EAAE,CAAC,YAAY,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;QAChE,SAAS,EAAE,0BAA0B;QACrC,QAAQ,EAAE,SAAS,OAAO,aAAa;QACvC,MAAM,EAAE,WAAW,OAAO,eAAe;QACzC,QAAQ,EAAE,6BAA6B;KACxC,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;IACzH,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,CAAA;IACxB,MAAM,cAAc,GAAG,IAAI,GAAG,EAAE,CAAA;IAEhC,KAAK,MAAM,QAAQ,IAAI,UAAU,EAAE,CAAC;QAClC,IAAI,OAAO,QAAQ,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAChF,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,oBAAoB,EAAE,QAAQ,EAAE,KAAK;gBAC1E,OAAO,EAAE,2DAA2D,EAAC,CAAC,CAAA;QAC1E,CAAC;QACD,MAAM,UAAU,GAAG,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;QAC5C,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAA;QAErC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,oBAAoB,EAAE,QAAQ,EAAE,KAAK;gBAC1E,OAAO,EAAE,0BAA0B,QAAQ,0CAA0C,EAAC,CAAC,CAAA;QAC3F,CAAC;QACD,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAA;QACtD,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QAE7C,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,IAAI,UAAU,EAAE,CAAC;YACrD,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,oBAAoB,EAAE,QAAQ,EAAE,KAAK;gBAC1E,OAAO,EAAE,4BAA4B,QAAQ,UAAU,UAAU,iBAAiB,QAAQ,IAAI,EAAC,CAAC,CAAA;QACpG,CAAC;QACD,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;QACxC,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IAChC,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;;;GAMG;AACH,SAAS,gBAAgB,CAAC,QAAQ,EAAE,KAAK;IACvC,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAA;IAC5C,MAAM,OAAO,GAAG,aAAa,CAAC,WAAW,CAAA;IACzC,MAAM,YAAY,GAAG,aAAa,CAAC,YAAY,CAAA;IAC/C,MAAM,UAAU,GAAG,aAAa,CAAC,UAAU,CAAA;IAC3C,MAAM,UAAU,GAAG;QACjB,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,qBAAqB;QACvG,aAAa,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB;QAChG,mBAAmB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,uBAAuB;QAClH,wBAAwB,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,0BAA0B;QACxG,aAAa,EAAE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB;QACzF,sBAAsB,EAAE,wBAAwB;QAChD,qBAAqB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,qBAAqB;QACpF,sBAAsB,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,oBAAoB;QAC1F,oBAAoB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,wBAAwB;QAC9F,QAAQ,KAAK,CAAC,QAAQ,EAAE,EAAE,QAAQ,KAAK,CAAC,SAAS,EAAE,EAAE,QAAQ,YAAY,EAAE;QAC3E,QAAQ,KAAK,CAAC,QAAQ,EAAE,EAAE,QAAQ,KAAK,CAAC,MAAM,EAAE;QAChD,GAAG,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,QAAQ,IAAI,EAAE,EAAE,aAAa,IAAI,EAAE,CAAC,CAAC;QAC1E,aAAa,YAAY,EAAE,EAAE,eAAe,KAAK,CAAC,QAAQ,EAAE,EAAE,iBAAiB,KAAK,CAAC,MAAM,EAAE;KAC9F,CAAA;IACD,MAAM,GAAG,GAAG,sBAAsB,CAAC,UAAU,CAAC,CAAA;IAC9C;;;;OAIG;IACH,MAAM,EAAE,GAAG,QAAQ,CAAC,EAAE;QACpB,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QAE/B,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,SAAS,CAAC,mCAAmC,QAAQ,IAAI,CAAC,CAAA;QAEhF,OAAO,KAAK,CAAA;IACd,CAAC,CAAA;IACD,2EAA2E;IAC3E,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAA;IAC1B;;;;;OAKG;IACH,MAAM,GAAG,GAAG,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE;QACtC,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,CAAA;QAE3C,OAAO,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,QAAQ,EAAC,CAAC,CAAA;QAC9B,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IAChC,CAAC,CAAA;IACD;;;;OAIG;IACH,MAAM,IAAI,GAAG,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,WAAW,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC1E;;;;OAIG;IACH,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAEpG,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;QACpC,GAAG,CAAC,cAAc,EAAE,aAAa,IAAI,EAAE,EAAE,CAAC,qBAAqB,EAAE,aAAa,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;QACrG,GAAG,CAAC,kBAAkB,EAAE,QAAQ,IAAI,EAAE,EAAE,CAAC,yBAAyB,EAAE,uCAAuC;YACzG,CAAC,SAAS,EAAE,GAAG,oBAAoB,CAAC,aAAa,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACjG,CAAC;IACD,GAAG,CAAC,cAAc,EAAE,aAAa,YAAY,EAAE,EAAE,CAAC,qBAAqB,EAAE,aAAa,EAAE,CAAC,QAAQ,YAAY,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;IACrH,GAAG,CAAC,cAAc,EAAE,eAAe,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,qBAAqB,EAAE,aAAa,EAAE,CAAC,QAAQ,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;IAC3H,GAAG,CAAC,cAAc,EAAE,iBAAiB,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,qBAAqB,EAAE,aAAa,EAAE,CAAC,QAAQ,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;IACzH,GAAG,CAAC,uBAAuB,EAAE,iBAAiB,EAAE,CAAC,8BAA8B,EAAE,qBAAqB,EAAE,CAAC,SAAS,CAAC,GAAG;QACpH,gBAAgB,EAAE,0BAA0B,EAAE,CAAC,YAAY,CAAC,GAAG;QAC/D,CAAC,iBAAiB,EAAE,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IAC7E,GAAG,CAAC,uBAAuB,EAAE,mBAAmB,EAAE,CAAC,8BAA8B,EAAE,qBAAqB,EAAE,CAAC,SAAS,CAAC,GAAG;QACtH,gBAAgB,EAAE,0BAA0B,EAAE,CAAC,YAAY,CAAC,GAAG;QAC/D,CAAC,iBAAiB,EAAE,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IAC7E,GAAG,CAAC,kBAAkB,EAAE,QAAQ,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,yBAAyB,EAAE,oCAAoC;QAChH,UAAU,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACvE,GAAG,CAAC,kBAAkB,EAAE,QAAQ,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC,yBAAyB,EAAE,qCAAqC;QAClH,UAAU,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACxE,GAAG,CAAC,kBAAkB,EAAE,QAAQ,YAAY,EAAE,EAAE,CAAC,yBAAyB,EAAE,0CAA0C;QACpH,CAAC,SAAS,EAAE,qBAAqB,CAAC,cAAc,EAAE,YAAY,CAAC,EAAE,GAAG,CAAC,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACtG,GAAG,CAAC,kBAAkB,EAAE,QAAQ,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,yBAAyB,EAAE,uCAAuC;QACnH,CAAC,SAAS,EAAE,GAAG,oBAAoB,CAAC,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACzG,GAAG,CAAC,kBAAkB,EAAE,QAAQ,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,yBAAyB,EAAE,uCAAuC;QACjH,CAAC,SAAS,EAAE,GAAG,oBAAoB,CAAC,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACvG,GAAG,CAAC,kBAAkB,EAAE,aAAa,EAAE,CAAC,yBAAyB,EAAE,yCAAyC,EAAE,qBAAqB;QACjI,CAAC,WAAW,EAAE,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE,SAAS,CAAC,EAAE,kCAAkC,CAAC,CAAC,CAAA;IAC/G,GAAG,CAAC,kBAAkB,EAAE,eAAe,EAAE,CAAC,yBAAyB,EAAE,sCAAsC,EAAE,qBAAqB;QAChI,CAAC,WAAW,EAAE,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,EAAE,kCAAkC,CAAC,CAAC,CAAA;IACvH,GAAG,CAAC,kBAAkB,EAAE,iBAAiB,EAAE,CAAC,yBAAyB,EAAE,sCAAsC,EAAE,qBAAqB;QAClI,CAAC,WAAW,EAAE,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE,mBAAmB,CAAC,EAAE,kCAAkC,CAAC,CAAC,CAAA;IAEzH,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,UAAU,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAA;IAC1I,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,UAAU,eAAe,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAA;IAE9I,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,IAAI,CAAC;YACtE,EAAE,CAAC,qBAAqB,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,QAAQ,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC;YAClH,EAAE,CAAC,gBAAgB,CAAC;SACrB,CAAC,YAAY,EAAE,2BAA2B,CAAC,CAAC,CAAA;IAC7C,GAAG,CAAC,UAAU,EAAE,eAAe,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,IAAI,CAAC,CAAC,EAAE,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC,YAAY;QACtI,CAAC,SAAS,EAAE,qBAAqB,CAAC,YAAY,EAAE,UAAU,CAAC,EAAE,GAAG,CAAC,EAAE,2BAA2B,CAAC,CAAC,CAAA;IAClG,GAAG,CAAC,UAAU,EAAE,iBAAiB,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,IAAI,CAAC,aAAa,CAAC,YAAY;QACrG,mBAAmB,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACpD,GAAG,CAAC,UAAU,EAAE,mBAAmB,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,IAAI,CAAC,eAAe,CAAC,YAAY;QACzG,qBAAqB,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACtD,GAAG,CAAC,UAAU,EAAE,qBAAqB,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,IAAI,CAAC,CAAC,EAAE,CAAC,QAAQ,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,QAAQ,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,YAAY;QACzJ,uBAAuB,EAAE,2BAA2B,CAAC,CAAC,CAAA;IACxD,GAAG,CAAC,UAAU,EAAE,aAAa,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,IAAI,CAAC,CAAC,EAAE,CAAC,QAAQ,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,YAAY;QAClH,eAAe,EAAE,2BAA2B,CAAC,CAAC,CAAA;IAChD,GAAG,CAAC,UAAU,EAAE,eAAe,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,IAAI,CAAC,CAAC,EAAE,CAAC,QAAQ,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,YAAY;QAClH,iBAAiB,EAAE,2BAA2B,CAAC,CAAC,CAAA;IAClD,GAAG,CAAC,UAAU,EAAE,gBAAgB,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,IAAI,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC,YAAY;QACtJ,kBAAkB,EAAE,2BAA2B,CAAC,CAAC,CAAA;IAEnD,eAAe,CAAC,GAAG,EAAE,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,EAAE,EAAE,oCAAoC,EAAE,aAAa,EAC3G,iBAAiB,EAAE,CAAC,mBAAmB,EAAE,sBAAsB,EAAE,qBAAqB,CAAC,EAAE,EAAE,CAAC,CAAA;IAC9F,eAAe,CAAC,GAAG,EAAE,EAAE,EAAE,aAAa,EAAE,cAAc,EAAE,OAAO,EAAE,yCAAyC,EAAE,eAAe,EACzH,mBAAmB,EAAE,CAAC,qBAAqB,EAAE,wBAAwB,EAAE,uBAAuB,CAAC,EAAE,CAAC,sBAAsB,CAAC,CAAC,CAAA;IAC5H,eAAe,CAAC,GAAG,EAAE,EAAE,EAAE,aAAa,EAAE,gBAAgB,EAAE,SAAS,EAAE,0CAA0C,EAAE,iBAAiB,EAChI,qBAAqB,EAAE,CAAC,uBAAuB,EAAE,0BAA0B,EAAE,yBAAyB,CAAC,EAAE,CAAC,wBAAwB,CAAC,CAAC,CAAA;IACtI,GAAG,CAAC,YAAY,EAAE,SAAS,EAAE,CAAC,mBAAmB,EAAE,4DAA4D;QAC7G,4BAA4B,EAAE,CAAC,qBAAqB,CAAC,GAAG,EAAE,yBAAyB,EAAE,6BAA6B;QAClH,+BAA+B,EAAE,eAAe,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,qBAAqB,EAAE,CAAC,gBAAgB,CAAC,GAAG;QACjH,wBAAwB,EAAE,qBAAqB;QAC/C,gBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAA;IAElG,aAAa,CAAC,GAAG,EAAE,EAAE,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,EAAE,CAAC,CAAA;IAC7E,aAAa,CAAC,GAAG,EAAE,EAAE,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,CAAC,aAAa,YAAY,EAAE,CAAC,CAAC,CAAA;IACtG,aAAa,CAAC,GAAG,EAAE,EAAE,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,CAAA;IAC9H,KAAK,MAAM,MAAM,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;QAC1C,aAAa,CAAC,GAAG,EAAE,EAAE,EAAE,yBAAyB,EAAE,SAAS,MAAM,aAAa,EAAE,EAAE,CAAC,CAAA;QACnF,aAAa,CAAC,GAAG,EAAE,EAAE,EAAE,wBAAwB,EAAE,SAAS,MAAM,YAAY,EAAE,EAAE,CAAC,CAAA;IACnF,CAAC;IACD,aAAa,CAAC,GAAG,EAAE,EAAE,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAC,eAAe,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;IACxG,aAAa,CAAC,GAAG,EAAE,EAAE,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,CAAC,iBAAiB,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IAC1G,GAAG,CAAC,qBAAqB,EAAE,sBAAsB,EAAE,CAAC,4BAA4B,EAAE,YAAY,EAAE,CAAC,YAAY,CAAC,GAAG;QAC/G,iBAAiB,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAA;IAC7C,GAAG,CAAC,qBAAqB,EAAE,wBAAwB,EAAE,CAAC,4BAA4B,EAAE,YAAY,EAAE,CAAC,YAAY,CAAC,GAAG;QACjH,iBAAiB,EAAE,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAA;IAE/C,KAAK,MAAM,KAAK,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;QAC3D,KAAK,MAAM,OAAO,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;YAC3C,MAAM,QAAQ,GAAG,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,CAAC,CAAA;YAEpE,GAAG,CAAC,sBAAsB,EAAE,UAAU,KAAK,IAAI,OAAO,EAAE,EAAE,CAAC,6BAA6B;gBACtF,gCAAgC,EAAE,CAAC,QAAQ,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,qBAAqB,EAAE,GAAG,QAAQ,EAAE,YAAY,CAAC;gBACnH,UAAU,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,CAAA;QAC3D,CAAC;QACD,GAAG,CAAC,qBAAqB,EAAE,eAAe,KAAK,EAAE,EAAE,CAAC,4BAA4B;YAC9E,4BAA4B,IAAI,CAAC,CAAC,EAAE,CAAC,UAAU,KAAK,QAAQ,CAAC,EAAE,EAAE,CAAC,UAAU,KAAK,UAAU,CAAC,CAAC,CAAC,YAAY;YAC1G,oCAAoC,EAAE,qCAAqC,CAAC,CAAC,CAAA;IACjF,CAAC;IAED,MAAM,KAAK,GAAG,CAAC,cAAc,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,UAAU;QAC/G,iBAAiB,EAAE,YAAY,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,qBAAqB;QACxG,sBAAsB,EAAE,qBAAqB,CAAC,CAAA;IAChD,MAAM,MAAM,GAAG,IAAI,uBAAuB,EAAE,CAAA;IAE5C,MAAM,CAAC,MAAM,CAAC,kGAAkG,CAAC,CAAA;IAEjH,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE,CAAC;QAC5B,MAAM,OAAO,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QAE5G,MAAM,CAAC,MAAM,CAAC,cAAc,OAAO,eAAe,CAAC,CAAA;QACnD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;YAChD,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBAC9B,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;gBACvB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;gBACnB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;YACrB,CAAC;YACD,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QAC3B,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,UAAU,OAAO,eAAe,CAAC,CAAA;IACjD,CAAC;IACD,MAAM,CAAC,MAAM,CAAC,wBAAwB,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;IAE5D,OAAO,MAAM,CAAC,MAAM,EAAE,CAAA;AACxB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,eAAe,CAAC,GAAG,EAAE,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EACrH,MAAM,EAAE,YAAY;IACpB;;;;OAIG;IACH,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC/E,MAAM,IAAI,GAAG,CAAC,IAAI,EAAE,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,EAAE,GAAG,UAAU,GAAG,CAAC,CAAA;IAEtG,GAAG,CAAC,iBAAiB,EAAE,QAAQ,EAAE,CAAC,wBAAwB,EAAE,4BAA4B,EAAE,CAAC,iBAAiB,CAAC,GAAG;QAC9G,oBAAoB,KAAK,CAAC,MAAM,CAAC,YAAY,EAAE,kBAAkB,EAAE,qBAAqB,KAAK,CAAC,YAAY,CAAC,YAAY;QACvH,CAAC,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,gBAAgB,EAAE,GAAG,IAAI,EAAE,GAAG,CAAC,EAAE,sBAAsB,EAAE,CAAC,gBAAgB,CAAC,GAAG;QAC1G,iBAAiB,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAA;AAChD,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,aAAa,CAAC,GAAG,EAAE,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK;IACtD,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAElE,GAAG,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC,SAAS,OAAO,GAAG,EAAE,+BAA+B,EAAE,cAAc,KAAK,YAAY;QAC3G,yCAAyC,CAAC,CAAC,CAAA;AAC/C,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK;IACzD,8EAA8E;IAC9E,MAAM,MAAM,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC;QAClC,oBAAoB,EAAE,IAAI;QAC1B,qBAAqB,EAAE,IAAI;KAC5B,CAAC,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC;QACnB,uBAAuB,EAAE,IAAI;QAC7B,cAAc,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QAC1C,0BAA0B,EAAE,qBAAqB,CAAC,kBAAkB,EAAE,aAAa,CAAC,gBAAgB,CAAC;QACrG,yBAAyB,EAAE,qBAAqB,CAAC,kBAAkB,EAAE,aAAa,CAAC,gBAAgB,CAAC;QACpG,mBAAmB,EAAE,qBAAqB,CAAC,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC;QAClF,YAAY,EAAE,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC;QAC7E,OAAO,EAAE,UAAU;QACnB,mBAAmB,EAAE,SAAS,CAAC,0BAA0B,CAAC;QAC1D,sBAAsB,EAAE,GAAG;KAC5B,CAAC,CAAC,CAAC,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC;QACrB,aAAa,EAAE,SAAS,CAAC,cAAc,CAAC;QACxC,yBAAyB,EAAE,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,aAAa,CAAC,gBAAgB,CAAC,EAAE,QAAQ,CAAC;QAChH,mBAAmB,EAAE,CAAC,qBAAqB,CAAC,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAC7F,YAAY,EAAE,gBAAgB;QAC9B,SAAS,EAAE,CAAC,0BAA0B,EAAE,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC;YACrG,OAAO,EAAE,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC;KAClF,CAAC,CAAC,CAAC;QACF,yBAAyB,EAAE,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,aAAa,CAAC,gBAAgB,CAAC,EAAE,UAAU,CAAC;QAClH,mBAAmB,EAAE,CAAC,qBAAqB,CAAC,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC;QAC/F,YAAY,EAAE,gBAAgB;QAC9B,gBAAgB,EAAE,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC;KAClF,CAAA;IAED,IAAI,OAAO,IAAI,SAAS;QAAE,MAAM,CAAC,wBAAwB,GAAG,SAAS,CAAC,IAAI,CAAC,CAAA;IAE3E,sCAAsC;IACtC,MAAM,MAAM,GAAG,EAAE,CAAA;IAEjB,KAAK,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC;QAChE,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;QAEzB,IAAI,KAAK,GAAG,CAAC;YAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAChC,MAAM,CAAC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,CAAA;QAChC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QACxD,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IAClB,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;GAIG;AACH,SAAS,SAAS,CAAC,KAAK;IACtB,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;AAC9B,CAAC;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,aAAa,EAAE,IAAI;IAC/C,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;QACpD,OAAO,CAAC,IAAI,EAAE,qBAAqB,CAAC,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAA;IACjI,CAAC;IACD,IAAI,IAAI,IAAI,aAAa,CAAC,YAAY,EAAE,CAAC;QACvC,OAAO,CAAC,IAAI,EAAE,qBAAqB,CAAC,cAAc,EAAE,aAAa,CAAC,YAAY,CAAC,EAAE,IAAI,CAAC,CAAA;IACxF,CAAC;IACD,IAAI,IAAI,IAAI,SAAS,aAAa,CAAC,WAAW,aAAa,EAAE,CAAC;QAC5D,OAAO,CAAC,UAAU,EAAE,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC,CAAA;IACvG,CAAC;IACD,IAAI,IAAI,IAAI,WAAW,aAAa,CAAC,WAAW,eAAe,EAAE,CAAC;QAChE,OAAO,CAAC,YAAY,EAAE,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC,CAAA;IAC3G,CAAC;IAED,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAA;AAC1B,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,QAAQ;IAClC,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,WAAW,CAAA;IAClD,MAAM,KAAK,GAAG,sBAAsB,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;IACtE,MAAM,MAAM,GAAG,sBAAsB,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;IAC3E,MAAM,QAAQ,GAAG,sBAAsB,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAA;IACjF;;;;;;OAMG;IACH,MAAM,SAAS,GAAG,CAAC,UAAU,EAAE,eAAe,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;;wCAElB,EAAE;iCACT,EAAE,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE,GAAG,eAAe;iCACnE,EAAE,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE,GAAG,UAAU;iDAC9C,EAAE,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE;kCAChE,CAAC,CAAA;IACjC,MAAM,MAAM,GAAG,IAAI,uBAAuB,EAAE,CAAA;IAE5C,MAAM,CAAC,MAAM,CAAC;;;;;aAKH,CAAC,CAAA;IACZ,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;IAC3C,MAAM,CAAC,MAAM,CAAC;;;;;;;aAOH,CAAC,CAAA;IACZ,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC,CAAA;IACzD,MAAM,CAAC,MAAM,CAAC;;;aAGH,CAAC,CAAA;IACZ,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,gBAAgB,EAAE,QAAQ,CAAC,CAAC,CAAA;IAC/D,MAAM,CAAC,MAAM,CAAC;;;;;;UAMN,CAAC,CAAA;IACT,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;IAC3C,MAAM,CAAC,MAAM,CAAC;;;;;UAKN,CAAC,CAAA;IACT,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;IAC3C,MAAM,CAAC,MAAM,CAAC;;;;;;CAMf,CAAC,CAAA;IAEA,OAAO,MAAM,CAAC,MAAM,EAAE,CAAA;AACxB,CAAC;AAED;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,aAAa;IAC5C,MAAM,MAAM,GAAG,IAAI,uBAAuB,EAAE,CAAA;IAE5C,MAAM,CAAC,MAAM,CAAC;;;8BAGc,CAAC,CAAA;IAC7B,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAA;IACxF,MAAM,CAAC,MAAM,CAAC,gCAAgC,CAAC,CAAA;IAC/C,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAA;IACxF,MAAM,CAAC,MAAM,CAAC,0BAA0B,CAAC,CAAA;IACzC,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC,CAAA;IAC5E,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAA;IAClC,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,CAAA;IAC9E,MAAM,CAAC,MAAM,CAAC;;;;CAIf,CAAC,CAAA;IAEA,OAAO,MAAM,CAAC,MAAM,EAAE,CAAA;AACxB,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,aAAa;IACpC,MAAM,MAAM,GAAG,IAAI,uBAAuB,EAAE,CAAA;IAE5C,MAAM,CAAC,MAAM,CAAC;;;;;WAKL,CAAC,CAAA;IACV,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA;IACzF,MAAM,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBf,CAAC,CAAA;IAEA,OAAO,MAAM,CAAC,MAAM,EAAE,CAAA;AACxB,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,aAAa;IACpC,MAAM,MAAM,GAAG,IAAI,uBAAuB,EAAE,CAAA;IAE5C,MAAM,CAAC,MAAM,CAAC,kCAAkC,CAAC,CAAA;IACjD,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC,CAAA;IAC5E,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAA;IACjC,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,CAAA;IAC9E,MAAM,CAAC,MAAM,CAAC;;;;;;;;;;;;;CAaf,CAAC,CAAA;IAEA,OAAO,MAAM,CAAC,MAAM,EAAE,CAAA;AACxB,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,aAAa;IAClC,MAAM,MAAM,GAAG,IAAI,uBAAuB,EAAE,CAAA;IAE5C,MAAM,CAAC,MAAM,CAAC,+BAA+B,CAAC,CAAA;IAC9C,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,CAAA;IAC9E,MAAM,CAAC,MAAM,CAAC;;;;;;;CAOf,CAAC,CAAA;IAEA,OAAO,MAAM,CAAC,MAAM,EAAE,CAAA;AACxB,CAAC;AAED;;;;GAIG;AACH,SAAS,SAAS,CAAC,KAAK;IACtB,OAAO,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC;SAClF,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;AACzD,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM;IAChD,OAAO;QACL,OAAO;QACP,WAAW,EAAE,MAAM;QACnB,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC;YACjG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,YAAY;QAC1F,SAAS,EAAE,WAAW;QACtB,IAAI;QACJ,UAAU,EAAE,EAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,EAAE,EAAC;QAC3D,IAAI;KACL,CAAA;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,uBAAuB,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM;IAClE,KAAK,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAC,GAAG,IAAI,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC,CAAA;IAEzE,OAAO,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;AAC5D,CAAC;AAED;;;;GAIG;AACH,SAAS,sBAAsB,CAAC,KAAK;IACnC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAA;AACxD,CAAC;AAED;;;;GAIG;AACH,SAAS,QAAQ,CAAC,KAAK;IACrB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IACpD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IAEvC,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAC9F,CAAC;AAED;;;;;GAKG;AACH,SAAS,sBAAsB,CAAC,SAAS;IACvC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QACnG,oBAAoB,CAAC,8DAA8D,CAAC,CAAA;IACtF,CAAC;IACD,MAAM,WAAW,GAAG,SAAS,CAAC,WAAW,CAAA;IACzC,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,CAAA;IACvC,MAAM,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,CAAA;IACvD,MAAM,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,CAAA;IACnD,MAAM,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,CAAA;IACnD,MAAM,WAAW,GAAG,SAAS,CAAC,WAAW,CAAA;IAEzC,IAAI,OAAO,WAAW,IAAI,QAAQ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;QAChF,oBAAoB,CAAC,uDAAuD,CAAC,CAAA;IAC/E,CAAC;IACD,IAAI,OAAO,UAAU,IAAI,QAAQ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QAC9E,oBAAoB,CAAC,sDAAsD,CAAC,CAAA;IAC9E,CAAC;IACD,IAAI,OAAO,kBAAkB,IAAI,QAAQ,IAAI,CAAC,YAAY,CAAC,kBAAkB,EAAE,CAAC,CAAC,EAAE,CAAC;QAClF,oBAAoB,CAAC,0FAA0F,CAAC,CAAA;IAClH,CAAC;IACD,IAAI,OAAO,gBAAgB,IAAI,QAAQ,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE,CAAC,CAAC;QAC3E,CAAC,gBAAgB,CAAC,UAAU,CAAC,GAAG,kBAAkB,GAAG,CAAC,EAAE,CAAC;QACzD,oBAAoB,CAAC,uFAAuF,CAAC,CAAA;IAC/G,CAAC;IACD,IAAI,OAAO,gBAAgB,IAAI,QAAQ,IAAI,CAAC,mCAAmC,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACvG,oBAAoB,CAAC,4EAA4E,CAAC,CAAA;IACpG,CAAC;IACD,IAAI,OAAO,WAAW,IAAI,QAAQ,IAAI,WAAW,CAAC,MAAM,IAAI,CAAC,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,WAAW;QAChG,CAAC,GAAG,WAAW,CAAC,CAAC,MAAM,GAAG,EAAE,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;QACrG,oBAAoB,CAAC,8FAA8F,CAAC,CAAA;IACtH,CAAC;IACD,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,SAAS,CAAA;IACpD,MAAM,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,iBAAiB,CAAA;IAChE,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,SAAS,CAAA;IAElD,IAAI,UAAU,IAAI,SAAS,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC;QAAE,oBAAoB,CAAC,iDAAiD,CAAC,CAAA;IACvI,IAAI,YAAY,IAAI,iBAAiB,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;QAC3E,oBAAoB,CAAC,2DAA2D,CAAC,CAAA;IACnF,CAAC;IACD,IAAI,SAAS,IAAI,SAAS;QAAE,oBAAoB,CAAC,2DAA2D,CAAC,CAAA;IAC7G,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,EAAE,CAAA;IAE3C,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnE,oBAAoB,CAAC,8DAA8D,CAAC,CAAA;IACtF,CAAC;IACD,MAAM,WAAW,GAAG,qBAAqB,CAAC,SAAS,CAAC,WAAW,EAAE,aAAa,CAAC,CAAA;IAC/E,MAAM,YAAY,GAAG,qBAAqB,CAAC,SAAS,CAAC,YAAY,EAAE,cAAc,CAAC,CAAA;IAClF,MAAM,mBAAmB,GAAG,qBAAqB,CAAC,SAAS,CAAC,mBAAmB,EAAE,sBAAsB,CAAC,CAAA;IACxG,MAAM,YAAY,GAAG,qBAAqB,CAAC,SAAS,CAAC,YAAY,EAAE,cAAc,CAAC,CAAA;IAElF,OAAO;QACL,gBAAgB;QAChB,YAAY;QACZ,gBAAgB;QAChB,WAAW;QACX,YAAY;QACZ,SAAS,EAAE,EAAE;QACb,SAAS,EAAE,SAAS;QACpB,UAAU;QACV,kBAAkB;QAClB,WAAW;QACX,mBAAmB;QACnB,WAAW;QACX,YAAY,EAAE,iBAAiB;QAC/B,UAAU,EAAE,SAAS;KACtB,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,qBAAqB,CAAC,SAAS,EAAE,KAAK;IAC7C,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,EAAE,CAAA;IACtC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,MAAM,IAAI,CAAC;QAAE,oBAAoB,CAAC,gBAAgB,KAAK,qBAAqB,CAAC,CAAA;IAEvH,OAAO,EAAE,CAAA;AACX,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,KAAK,EAAE,QAAQ;IACnC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAE9B,OAAO,KAAK,CAAC,MAAM,IAAI,QAAQ,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;AAChH,CAAC;AAED;;;;;GAKG;AACH,SAAS,eAAe,CAAC,SAAS,EAAE,YAAY;IAC9C,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,EAAE,CAAA;IACtC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,YAAY,CAAC,2CAA2C,CAAC,CAAA;IACvF,wEAAwE;IACxE,MAAM,MAAM,GAAG,EAAE,CAAA;IAEjB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACzD,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAA;QAE9B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAChF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,IAAI,WAAW,CAAC,IAAI;YAAE,YAAY,CAAC,SAAS,KAAK,oCAAoC,CAAC,CAAA;QACjH,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAA;QACvB,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAA;QAC7B,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAA;QACjC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAA;QAE3B,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,YAAY,GAAG,CAAC,IAAI,IAAI,IAAI,GAAG,YAAY,gBAAgB,EAAE,CAAC;YACjH,YAAY,CAAC,SAAS,KAAK,gCAAgC,YAAY,IAAI,CAAC,CAAA;QAC9E,CAAC;QACD,IAAI,OAAO,OAAO,IAAI,QAAQ,IAAI,CAAC,CAAC,OAAO,YAAY,UAAU,CAAC;YAChE,OAAO,OAAO,IAAI,QAAQ,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;YACtF,OAAO,YAAY,UAAU,IAAI,OAAO,CAAC,UAAU,IAAI,CAAC;YAAE,YAAY,CAAC,UAAU,IAAI,qCAAqC,CAAC,CAAA;QAC7H,IAAI,OAAO,SAAS,IAAI,QAAQ,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YACnG,YAAY,CAAC,UAAU,IAAI,0CAA0C,CAAC,CAAA;QACxE,CAAC;QACD,MAAM,QAAQ,GAAG,OAAO,OAAO,IAAI,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,CAAA;QAC/E,MAAM,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;QAEtE,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,UAAU,EAAE,CAAC;YACzF,YAAY,CAAC,UAAU,IAAI,6CAA6C,CAAC,CAAA;QAC3E,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;IAC3D,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAE1F,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAK;IAC1B,IAAI,OAAO,KAAK,CAAC,OAAO,IAAI,QAAQ;QAAE,OAAO;YAC3C,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,WAAW;YACtB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,UAAU,EAAE,EAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,2CAA2C,KAAK,CAAC,MAAM,IAAI,EAAE,cAAc,EAAE,EAAE,EAAC;YACxH,IAAI,EAAE,UAAU;SACjB,CAAA;IACD,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IAE7C,OAAO;QACL,OAAO;QACP,WAAW,EAAE,QAAQ;QACrB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,SAAS,EAAE,WAAW;QACtB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,UAAU,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,CAAC;gBACrD,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,CAAC;wBACP,SAAS,EAAE,EAAC,GAAG,EAAE,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC,EAAC;wBAC9C,MAAM,EAAE,EAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,2CAA2C,KAAK,CAAC,MAAM,IAAI,EAAE,cAAc,EAAE,EAAE,EAAC;wBACpH,IAAI,EAAE,OAAO;qBACd,CAAC;aACH,CAAC,EAAC;QACH,IAAI,EAAE,UAAU;KACjB,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,OAAO;IACnC,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,mCAAmC,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAC,CAAC,CAAA;AACxG,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CAAC,OAAO;IAC3B,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,2BAA2B,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAC,CAAC,CAAA;AAChG,CAAC;AAED;;;;GAIG;AACH,SAAS,WAAW,CAAC,OAAO;IAC1B,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,0BAA0B,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAC,CAAC,CAAA;AAC/F,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY;IACvE,MAAM,SAAS,GAAG,oBAAoB,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAA;IAE5D,MAAM,CAAC,SAAS,CAAC,QAAQ,SAAS,MAAM,EAAE,+BAA+B,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IAC1F,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,aAAa,EAAE,EAAE;QACtD,MAAM,IAAI,GAAG,cAAc,aAAa,EAAE,CAAA;QAE1C,MAAM,CAAC,SAAS,CAAC,WAAW,EAAE,kCAAkC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACxF,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAC,CAAC,CAAA;QACvE,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,qBAAqB,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACnE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;QAC9F,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,6BAA6B,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAC3E,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,cAAc,EAAE,EAAE;YAC3D,MAAM,aAAa,GAAG,GAAG,IAAI,eAAe,cAAc,EAAE,CAAA;YAE5D,IAAI,cAAc;gBAAE,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,qBAAqB,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAA;YAC/F,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,oCAAoC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAA;YAC1F,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;YACzG,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,+BAA+B,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAA;YACrF,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI;gBAChG,IAAI,EAAE,GAAG,aAAa,OAAO,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;QACjD,CAAC,CAAC,CAAA;QACF,MAAM,CAAC,SAAS,CAAC,oDAAoD,EAAE,kCAAkC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACjI,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,WAAW,CAAC,UAAU,CAAC,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,CAAC,UAAU;YAChH,IAAI,EAAE,GAAG,IAAI,aAAa,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;QAC5C,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,8BAA8B,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAC/E,SAAS,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,OAAO,EAAE,YAAY,CAAC,CAAA;QACzE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,8BAA8B,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClF,CAAC,CAAC,CAAA;IACF,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,CAAC,SAAS,CAAC,kDAAkD,EAAE,6BAA6B,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAA;QACzI,MAAM,CAAC,SAAS,CAAC,wDAAwD,EAAE,mCAAmC,EAC5G,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAA;QACvC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,kBAAkB,EAAE,YAAY,CAAC,CAAA;QACnF,MAAM,CAAC,SAAS,CAAC,uCAAuC,EAAE,4BAA4B,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAA;QAC7H,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,6BAA6B,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAA;IAChG,CAAC;IACD,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,+BAA+B,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;AAC1E,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY;IAC1D,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,eAAe,KAAK,EAAE,EAAE,YAAY,CAAC,CAAC,CAAA;AACvI,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY;IAClE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAC5D,IAAI,SAAS,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;QACzC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,EAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAA;QAChG,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,qBAAqB,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACjE,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;QAC1F,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,2BAA2B,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACxE,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI;YAChG,IAAI,EAAE,GAAG,IAAI,OAAO,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;QACtC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,oBAAoB,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAClE,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,WAAW,EAAE,GAAG,IAAI,cAAc,EAAE,YAAY,CAAC,CAAA;QAClF,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACzD,IAAI,SAAS,CAAC,OAAO;YAAE,MAAM,CAAC,SAAS,CAAC,GAAG,MAAM,6BAA6B,SAAS,CAAC,IAAI,KAAK,EAC/F,oCAAoC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAC5D,OAAM;IACR,CAAC;IACD,IAAI,SAAS,CAAC,IAAI,IAAI,qBAAqB,EAAE,CAAC;QAC5C,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,SAAS,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;QAC1H,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,oBAAoB,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAClE,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,UAAU,EAAE,GAAG,IAAI,aAAa,EAAE,YAAY,CAAC,CAAA;QAChF,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACzD,OAAM;IACR,CAAC;IACD,IAAI,SAAS,CAAC,IAAI,IAAI,iBAAiB,EAAE,CAAC;QACxC,IAAI,CAAC,SAAS,CAAC,UAAU;YAAE,MAAM,IAAI,SAAS,CAAC,yCAAyC,CAAC,CAAA;QACzF,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAA;QACvE,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,gBAAgB,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAC5D,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,UAAU,EAAE,GAAG,IAAI,aAAa,EAAE,YAAY,CAAC,CAAA;QAChF,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACzD,OAAM;IACR,CAAC;IACD,IAAI,SAAS,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;QACvC,MAAM,CAAC,SAAS,CAAC,2BAA2B,EAAE,oBAAoB,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACxF,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,UAAU,EAAE,GAAG,IAAI,aAAa,EAAE,YAAY,CAAC,CAAA;QAChF,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,oBAAoB,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAClE,OAAM;IACR,CAAC;IACD,IAAI,SAAS,CAAC,IAAI,IAAI,aAAa;QAAE,MAAM,IAAI,SAAS,CAAC,mDAAmD,CAAC,CAAA;IAC7G,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAA;IACnE,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,qBAAqB,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjE,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,EAAE,GAAG,IAAI,YAAY,EAAE,YAAY,CAAC,CAAA;IAC9E,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,4BAA4B,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,aAAa,CAAC,CAAC,CAAA;IACtG,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,UAAU,EAAE,GAAG,MAAM,IAAI,EAAE,GAAG,IAAI,aAAa,EAAE,YAAY,CAAC,CAAA;IAC1F,MAAM,CAAC,SAAS,CAAC,GAAG,MAAM,GAAG,EAAE,4BAA4B,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,aAAa,CAAC,CAAC,CAAA;IAC5G,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;QACxB,MAAM,CAAC,SAAS,CAAC,WAAW,EAAE,0BAA0B,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC,CAAA;QACvG,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,EAAE,GAAG,MAAM,IAAI,EAAE,GAAG,IAAI,YAAY,EAAE,YAAY,CAAC,CAAA;QACxF,MAAM,CAAC,SAAS,CAAC,GAAG,MAAM,GAAG,EAAE,0BAA0B,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC,CAAA;IAC1G,CAAC;IACD,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;AAC3D,CAAC;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY;IAC5D,IAAI,UAAU,CAAC,IAAI,IAAI,sBAAsB,EAAE,CAAC;QAC9C,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;QAC5F,OAAM;IACR,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;QACxC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAA;QACxG,OAAM;IACR,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;QACxC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAA;QACnH,OAAM;IACR,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,IAAI,eAAe,EAAE,CAAC;QACvC,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAA;QAC5H,OAAM;IACR,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;QACxC,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,EAAE,aAAa,CAAC,CAAA;QAEvE,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,SAAS,CAAC,mCAAmC,UAAU,CAAC,UAAU,EAAE,aAAa,IAAI,CAAC,CAAA;QAC/G,MAAM,CAAC,MAAM,CAAC,oBAAoB,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE;YAC9F,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,CAAC,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ;SACtF,CAAC,CAAA;QACF,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,4BAA4B,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACzE,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE;YAC/C,IAAI,KAAK;gBAAE,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,oBAAoB,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;YAC7E,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,cAAc,KAAK,EAAE,EAAE,YAAY,CAAC,CAAA;QAC9E,CAAC,CAAC,CAAA;QACF,MAAM,CAAC,SAAS,CAAC,uBAAuB,EAAE,iCAAiC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAClG,OAAM;IACR,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,IAAI,iBAAiB,EAAE,CAAC;QACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAC,CAAC,CAAA;QACnE,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAC,CAAC,CAAA;QACtH,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,EAAE,GAAG,IAAI,UAAU,EAAE,YAAY,CAAC,CAAA;QAC3E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAC,CAAC,CAAA;QACnE,OAAM;IACR,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,IAAI,kBAAkB;QAAE,MAAM,IAAI,SAAS,CAAC,oDAAoD,CAAC,CAAA;IACpH,IAAI,UAAU,CAAC,SAAS,IAAI,aAAa,IAAI,UAAU,CAAC,SAAS,IAAI,gBAAgB,EAAE,CAAC;QACtF,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,SAAS,IAAI,aAAa,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,8BAA8B,EAC/G,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAC,CAAC,CAAA;QACnE,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,mCAAmC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAChF,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,GAAG,IAAI,OAAO,EAAE,YAAY,CAAC,CAAA;QACrE,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,0CAA0C,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QACxF,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,KAAK,EAAE,GAAG,IAAI,QAAQ,EAAE,YAAY,CAAC,CAAA;QACvE,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,mCAAmC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAChF,OAAM;IACR,CAAC;IACD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAC,CAAC,CAAA;IACnE,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,GAAG,IAAI,OAAO,EAAE,YAAY,CAAC,CAAA;IACrE,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,kBAAkB,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAC/D,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAC,CAAC,CAAA;IACvH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,kBAAkB,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAC/D,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,KAAK,EAAE,GAAG,IAAI,QAAQ,EAAE,YAAY,CAAC,CAAA;IACvE,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAC,CAAC,CAAA;AACrE,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,EAAE;IACpB,OAAO,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;AAC7F,CAAC;AAED;;;;GAIG;AACH,SAAS,qBAAqB,CAAC,SAAS;IACtC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;QAAE,qBAAqB,CAAC,KAAK,EAAE,2BAA2B,EAAE,SAAS,CAAC,CAAA;IACnG,MAAM,MAAM,GAAG,eAAe,CAAC,SAAS,CAAC,CAAA;IACzC,MAAM,iBAAiB,GAAG,MAAM,CAAC,UAAU,EAAE,OAAO,CAAA;IAEpD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,iBAAiB,CAAC,MAAM,IAAI,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,IAAI;QAC7G,iBAAiB,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,EAAE,QAAQ,IAAI,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,QAAQ,EAAE,CAAC;QACjH,qBAAqB,CAAC,KAAK,EAAE,gCAAgC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;IACjF,CAAC;IACD,uBAAuB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,MAAM,OAAO,GAAG;QACd,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,iBAAiB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QACtF,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QACrF,GAAG,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QACpF,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,iBAAiB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;KACnF,CAAA;IACD,MAAM,aAAa,GAAG,mEAAmE,CAAC,CAAC;QACzF,GAAG,MAAM;QACT,OAAO;QACP,EAAE,EAAE,MAAM;QACV,OAAO,EAAE,EAAE;QACX,cAAc,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,QAAQ;KAC9C,CAAC,CAAA;IAEF,OAAO;QACL,WAAW,EAAE,MAAM;QACnB,IAAI,EAAE,SAAS;QACf,OAAO,EAAE,CAAC,aAAa,CAAC;QACxB,OAAO,EAAE,eAAe,CAAC,iBAAiB,CAAC;KAC5C,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,iBAAiB,CAAC,WAAW,EAAE,UAAU;IAChD,OAAO;QACL,aAAa,EAAE,qBAAqB,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC;QACrD,YAAY,EAAE,WAAW,CAAC,IAAI;QAC9B,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,WAAW,CAAC,QAAQ;QAC9B,UAAU;KACX,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,uBAAuB,CAAC,MAAM,EAAE,QAAQ;IAC/C,MAAM,YAAY,GAAG,CAAC,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,EAAE,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC,CAAA;IACpH,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,YAAY;SACtC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,OAAO,WAAW,CAAC,EAAE,IAAI,QAAQ,CAAC;SACxD,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,EAAE,EAAE,GAAG,QAAQ,IAAI,WAAW,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAA;IAEzE,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;QACvC,IAAI,OAAO,WAAW,CAAC,EAAE,IAAI,QAAQ;YAAE,WAAW,CAAC,EAAE,GAAG,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,CAAA;IAC1F,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,CAAA;IACtB,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,eAAe,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAA;IAC9F;;;;OAIG;IACH,SAAS,KAAK,CAAC,KAAK;QAClB,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,OAAM;QACjE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QACf,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAClD,IAAI,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;oBACrF,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;gBACnD,CAAC;;oBAAM,KAAK,CAAC,MAAM,CAAC,CAAA;YACtB,CAAC;QACH,CAAC;;YAAM,KAAK,MAAM,MAAM,IAAI,KAAK;gBAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAClD,CAAC;IACD,KAAK,CAAC,MAAM,CAAC,CAAA;AACf,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAK;IAC1B,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAA;AAChI,CAAC","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport {isDenseArray} from \"../array.js\"\nimport {findPortableArtifactPathConflict, isSafeArtifactPath} from \"../artifact-path.js\"\nimport {createByteMapping} from \"../binary-mapping.js\"\nimport {SemantifoldDiagnostic, unsupportedCapability} from \"../diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {preflightSemanticProgram} from \"./program.js\"\nimport {emitScalarType, emitStringLiteral} from \"./scalars.js\"\nimport {SourceWriter} from \"./writer.js\"\n\n/** @type {Readonly<Set<import(\"../semantic/types.js\").SemanticLanguage>>} */\nconst iosSourceLanguages = new Set([\n  \"php\", \"ruby\", \"javascript\", \"typescript\", \"java\", \"kotlin\", \"python\", \"csharp\", \"go\", \"c\", \"cpp\", \"rust\", \"swift\", \"dart\"\n])\nconst configurationFields = new Set([\n  \"bundleIdentifier\", \"capabilities\", \"deploymentTarget\", \"displayName\", \"entitlements\", \"infoPlist\", \"lifecycle\",\n  \"moduleName\", \"organizationPrefix\", \"permissions\", \"privacyDeclarations\", \"productName\", \"resourceRoot\", \"sourceRoot\"\n])\nconst assetFields = new Set([\"content\", \"mediaType\", \"path\", \"sha256\"])\nconst generatorVersion = \"0.3.0\"\nconst excludedPathPatterns = Object.freeze([\n  \"**/*.xcuserstate\",\n  \"**/xcuserdata/**\",\n  \".swiftpm/**\",\n  \"DerivedData/**\",\n  \"build/**\"\n])\nconst mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\\/[A-Za-z0-9!#$&^_.+-]+(?:;[\\u0020-\\u007e]+)?$/u\nconst binaryOperations = Object.freeze({\n  BooleanAnd: \"&&\",\n  BooleanEqual: \"==\",\n  BooleanNotEqual: \"!=\",\n  BooleanOr: \"||\",\n  IntegerAdd: \"+\",\n  IntegerEqual: \"==\",\n  IntegerGreaterThan: \">\",\n  IntegerGreaterThanOrEqual: \">=\",\n  IntegerLessThan: \"<\",\n  IntegerLessThanOrEqual: \"<=\",\n  IntegerMultiply: \"*\",\n  IntegerNotEqual: \"!=\",\n  IntegerSubtract: \"-\",\n  StringConcat: \"+\",\n  StringEqual: \"==\",\n  StringNotEqual: \"!=\"\n})\nconst unaryOperations = Object.freeze({BooleanNot: \"!\", IntegerNegate: \"-\"})\nconst iosSwiftRuntime = `final class SemantifoldOutputSink {\n  private(set) var lines: [String] = []\n\n  func write(_ value: Int64) {\n    lines.append(String(value))\n  }\n\n  func write(_ value: Bool) {\n    lines.append(value ? \"true\" : \"false\")\n  }\n\n  func write(_ value: String) {\n    lines.append(value)\n  }\n}\n\nfunc semantifold_string_equal(_ left: String, _ right: String) -> Bool {\n  return left.unicodeScalars.elementsEqual(right.unicodeScalars)\n}\n\nfunc semantifold_string_not_equal(_ left: String, _ right: String) -> Bool {\n  return !left.unicodeScalars.elementsEqual(right.unicodeScalars)\n}\n\nfunc semantifold_keep_mutable<T>(_ value: inout T) {\n}\n`\n\n/** @typedef {{content: string, field: string}} ConfigurationFragment */\n/** @typedef {string | ConfigurationFragment} ConfigurationTextPart */\n/** @typedef {string | readonly ConfigurationTextPart[]} ConfigurationLine */\n/** @typedef {{end: number, field: string, start: number}} ConfigurationSpan */\n/** @typedef {{content: string, configurationSpans: ConfigurationSpan[]}} RenderedConfigurationText */\n/** @typedef {{end: number, field: string, path: string, start: number}} ConfigurationArtifactSpan */\n\n/** Records configuration causality while an owning renderer emits text. */\nclass ConfigurationTextWriter {\n  constructor() {\n    this.content = \"\"\n    /** @type {ConfigurationSpan[]} */\n    this.configurationSpans = []\n  }\n\n  /**\n   * Appends literal or field-owned text.\n   * @param {ConfigurationTextPart | readonly ConfigurationTextPart[]} value - Ordered output text.\n   */\n  append(value) {\n    const parts = Array.isArray(value) ? value : [value]\n\n    for (const part of parts) {\n      if (typeof part == \"string\") {\n        this.content += part\n      } else {\n        const start = this.content.length\n\n        this.content += part.content\n        this.configurationSpans.push({end: this.content.length, field: part.field, start})\n      }\n    }\n  }\n\n  /**\n   * Finishes renderer-owned text collection.\n   * @returns {RenderedConfigurationText} Finished content and causal spans.\n   */\n  finish() {\n    return {configurationSpans: this.configurationSpans, content: this.content}\n  }\n}\n\n/**\n * Marks text as causally owned by one normalized configuration field.\n * @param {string} field - Configuration field.\n * @param {string} content - Exact rendered token content.\n * @returns {ConfigurationFragment} Tagged token.\n */\nfunction configurationFragment(field, content) {\n  return {content, field}\n}\n\n/**\n * Preflights one complete project against the delivered Swift Tasks 001-004 profile.\n * @param {object} input - iOS application generation input.\n * @param {import(\"../semantic/types.js\").SemanticModule} [input.module] - Single module to normalize.\n * @param {import(\"../semantic/types.js\").SemanticProgram} [input.program] - Caller-owned Task 010 project.\n * @param {import(\"../semantic/types.js\").IosApplicationConfigurationInput} [input.configuration] - Closed application configuration.\n * @param {import(\"../semantic/types.js\").IosApplicationAssetInput[]} [input.assets] - Exact caller-provided assets.\n * @returns {{assets: import(\"../semantic/types.js\").IosApplicationAssetInput[], configuration: import(\"../semantic/types.js\").IosApplicationConfiguration, modulePaths: Map<string, string>, modules: import(\"../semantic/types.js\").SemanticModule[], program: import(\"../semantic/types.js\").SemanticProgram, sources: {content: string, filename: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} Prepared application program.\n */\nexport function preflightIosApplication(input) {\n  if (!isPlainObject(input) || Boolean(input.module) == Boolean(input.program)) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_APPLICATION_INPUT\",\n      language: \"ios\",\n      message: \"iOS application generation requires exactly one semantic module or program.\"\n    })\n  }\n  const configuration = normalizeConfiguration(input.configuration)\n  const program = input.program ?? normalizeSingleModule(input.module)\n  const prepared = preflightSemanticProgram({\n    backendLanguage: \"swift\",\n    diagnosticLanguage: \"ios\",\n    program,\n    sourceLanguages: iosSourceLanguages\n  })\n  const modulePaths = new Map(prepared.modules.map(module => [\n    /** @type {string} */ (Reflect.get(module, \"id\")),\n    `${configuration.sourceRoot}/Generated/${moduleName(/** @type {string} */ (Reflect.get(module, \"id\")))}.swift`\n  ]))\n  const assets = normalizeAssets(input.assets, configuration.resourceRoot)\n  const conflict = findPortableArtifactPathConflict([\n    `${configuration.sourceRoot}/Generated/SemantifoldRuntime.swift`,\n    ...modulePaths.values(),\n    `${configuration.resourceRoot}/Contents.json`,\n    ...assets.map(({path}) => path)\n  ])\n\n  if (conflict) invalidPath(`Application artifact path '${conflict.path}' has a ${conflict.kind} conflict${conflict.other ? ` with '${conflict.other}'` : \"\"}.`)\n\n  return {...prepared, assets, configuration, modulePaths}\n}\n\n/**\n * Generates the deterministic semantic Swift portion of one iOS application artifact set.\n * @param {Parameters<typeof preflightIosApplication>[0]} input - iOS generation request.\n * @returns {{artifacts: import(\"../semantic/types.js\").GeneratedSetArtifact[], metadata: {applicationManifest: string, platformQualification: string}, target: \"ios\"}} Candidate artifact set.\n */\nexport function generateIosApplication(input) {\n  const prepared = preflightIosApplication(input)\n  const semanticArtifacts = renderSemanticArtifacts(prepared)\n  const applicationPaths = applicationArtifactPaths(prepared)\n  const project = renderPbxProject(prepared, applicationPaths)\n  const scheme = renderSharedScheme(prepared)\n  const baseConfiguration = renderBaseConfiguration(prepared.configuration)\n  const infoPlist = renderInfoPlist(prepared.configuration)\n  const unitTests = renderUnitTests(prepared.configuration)\n  const uiTests = renderUiTests(prepared.configuration)\n  const configuration = prepared.configuration\n  const entryNamespace = `SemantifoldModule${moduleName(prepared.program.entryModule)}`\n  const app = `import SwiftUI\n\n@main\nstruct SemantifoldApplication: App {\n  var body: some Scene {\n    WindowGroup {\n      SemantifoldOutputView(lines: SemantifoldBridge.run())\n    }\n  }\n}\n`\n  const bridge = `enum SemantifoldBridge {\n  static func run() -> [String] {\n    return ${entryNamespace}.semantifoldEntry()\n  }\n}\n`\n  const view = `import SwiftUI\n\nstruct SemantifoldOutputView: View {\n  let lines: [String]\n\n  var body: some View {\n    Text(lines.joined(separator: \"\\\\n\"))\n      .accessibilityIdentifier(\"semantifold-output\")\n  }\n}\n`\n  const product = configuration.productName\n  /** @type {ConfigurationArtifactSpan[]} */\n  const configurationSpans = []\n  const artifacts = [\n    configuredSyntheticText(`${product}.xcodeproj/project.pbxproj`, \"manifest\", project,\n      configurationSpans,\n      \"Canonical deterministic Xcode project structure.\"),\n    configuredSyntheticText(`${product}.xcodeproj/xcshareddata/xcschemes/${product}.xcscheme`, \"support\",\n      scheme, configurationSpans, \"Canonical shared Xcode application/test scheme.\"),\n    configuredSyntheticText(\"Configuration/Base.xcconfig\", \"support\", baseConfiguration, configurationSpans,\n      \"Closed unsigned iOS build configuration.\"),\n    configuredSyntheticText(\"Configuration/Info.plist\", \"support\", infoPlist, configurationSpans,\n      \"Allowlisted iOS application property list.\"),\n    ...semanticArtifacts,\n    syntheticText(\"Sources/Application/App.swift\", \"entry\", app, \"Synthetic SwiftUI application lifecycle.\"),\n    syntheticText(\"Sources/Application/SemantifoldBridge.swift\", \"support\", bridge,\n      \"Synthetic bridge from SwiftUI to the semantic entry.\"),\n    syntheticText(\"Sources/Application/SemantifoldOutputView.swift\", \"support\", view,\n      \"Synthetic stable text output view and accessibility identifier.\"),\n    syntheticText(\"Assets.xcassets/Contents.json\", \"resource\", stringifyCanonicalJson({\n      info: {author: \"semantifold\", version: 1}\n    }), \"Base asset-catalog metadata; no application icon is synthesized.\"),\n    ...prepared.assets.map(assetArtifact),\n    configuredSyntheticText(`Tests/${product}Tests.swift`, \"support\", unitTests, configurationSpans,\n      \"Synthetic pure-logic determinism XCTest source.\"),\n    configuredSyntheticText(`UITests/${product}UITests.swift`, \"support\", uiTests, configurationSpans,\n      \"Synthetic XCUI accessibility-route test source.\")\n  ]\n  const manifestPath = \"semantifold-project.json\"\n\n  artifacts.push(syntheticText(manifestPath, \"manifest\",\n    renderProjectManifest(prepared, artifacts, manifestPath, configurationSpans),\n    \"Versioned iOS project ownership and provenance manifest.\"))\n\n  return {\n    artifacts,\n    metadata: {applicationManifest: manifestPath, platformQualification: \"deferred\"},\n    target: \"ios\"\n  }\n}\n\n/**\n * Renders the complete deterministic application ownership and provenance record.\n * @param {ReturnType<typeof preflightIosApplication>} prepared - Fully preflighted application.\n * @param {import(\"../semantic/types.js\").GeneratedSetArtifact[]} artifacts - All non-manifest output artifacts.\n * @param {string} manifestPath - Owned manifest path.\n * @param {ConfigurationArtifactSpan[]} configurationSpans - Renderer-owned configuration ranges.\n * @returns {string} Canonical manifest JSON.\n */\nfunction renderProjectManifest(prepared, artifacts, manifestPath, configurationSpans) {\n  const assetPaths = new Set(prepared.assets.map(({path}) => path))\n  const semanticArtifacts = artifacts.filter(artifact => artifact.provenance.kind == \"text\")\n  const configuration = prepared.configuration\n\n  return stringifyCanonicalJson({\n    configuration,\n    generator: {name: \"semantifold\", version: generatorVersion},\n    ownership: {\n      excludedPathPatterns,\n      ownedPaths: [...artifacts.map(({path}) => path), manifestPath]\n    },\n    platformRequirements: {\n      appleSdk: {status: \"deferred\"},\n      iosSimulator: {status: \"deferred\"},\n      macosHost: {status: \"deferred\"},\n      swiftc: {status: \"deferred\"},\n      xcode: {status: \"deferred\"},\n      xctest: {status: \"deferred\"},\n      xcuiautomation: {status: \"deferred\"}\n    },\n    provenance: {\n      assets: prepared.assets.map(asset => ({\n        contentKind: typeof asset.content == \"string\" ? \"text\" : \"binary\",\n        mediaType: asset.mediaType,\n        path: asset.path,\n        sha256: asset.sha256\n      })),\n      configuration: Object.keys(configuration).sort().map(field => ({\n        field,\n        manifestPointer: `/configuration/${field}`,\n        outputs: configurationOutputCitations(configurationSpans, field)\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: [\n        ...artifacts.filter(artifact => artifact.provenance.kind == \"synthetic\" && !assetPaths.has(artifact.path))\n          .map(({path}) => path),\n        manifestPath\n      ]\n    },\n    schema: \"SemantifoldIosProject\",\n    semanticProgram: semanticProgramManifest(prepared),\n    target: \"ios\",\n    version: 1\n  })\n}\n\n/**\n * Records stable semantic input identities and their generated Swift linkage.\n * @param {ReturnType<typeof preflightIosApplication>} prepared - Fully preflighted application.\n * @returns {Record<string, unknown>} Versioned semantic-program manifest section.\n */\nfunction semanticProgramManifest(prepared) {\n  const moduleIds = new Map(prepared.program.modules.map((module, index) => [module.id, index]))\n  const sourceContent = new Map(prepared.sources.map(source => [source.filename, source.content]))\n  const modules = prepared.program.modules.map(module => {\n    const id = module.id\n    const path = /** @type {string} */ (prepared.modulePaths.get(id))\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 iOS module '${id}' lost its source ownership.`)\n    const dependencies = [...new Set(module.imports.map(({moduleId}) => moduleId))]\n      .sort((left, right) => /** @type {number} */ (moduleIds.get(left)) - /** @type {number} */ (moduleIds.get(right)))\n\n    return {\n      dependencies,\n      generatedArtifacts: [path],\n      id,\n      namespace: `SemantifoldModule${moduleName(id)}`,\n      source: {\n        filename: source.filename,\n        id: source.id,\n        sha256: createHash(\"sha256\").update(content).digest(\"hex\")\n      }\n    }\n  })\n  const sources = prepared.program.sources.map(source => {\n    const content = sourceContent.get(source.filename)\n\n    if (content === undefined) throw new TypeError(`Preflighted iOS source '${source.filename}' lost its content.`)\n\n    return {\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(content).digest(\"hex\")\n    }\n  })\n  const entryId = prepared.program.entryModule\n  const entryArtifact = /** @type {string} */ (prepared.modulePaths.get(entryId))\n  const entryNamespace = `SemantifoldModule${moduleName(entryId)}`\n\n  return {\n    entry: {\n      applicationArtifact: `${prepared.configuration.sourceRoot}/Application/App.swift`,\n      bridgeArtifact: `${prepared.configuration.sourceRoot}/Application/SemantifoldBridge.swift`,\n      generatedArtifact: entryArtifact,\n      generatedFunctionIdentity: `${entryNamespace}.semantifoldEntry`,\n      moduleId: entryId\n    },\n    modules,\n    schema: \"SemantifoldIosSemanticProgram\",\n    sources,\n    version: 1\n  }\n}\n\n/**\n * Determines whether one closed semantic origin cites a source filename.\n * @param {import(\"../semantic/types.js\").SemanticOrigin} origin - Mapped origin.\n * @param {string} filename - Original caller filename.\n * @returns {boolean} Whether the source participates in the origin.\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 * Groups renderer-recorded configuration ranges without scanning generated text.\n * @param {ConfigurationArtifactSpan[]} spans - Causal artifact spans.\n * @param {string} field - Normalized configuration field.\n * @returns {{path: string, ranges: {end: number, start: number}[]}[]} Stable output citations.\n */\nfunction configurationOutputCitations(spans, field) {\n  /** @type {Map<string, {end: number, start: number}[]>} */\n  const byPath = new Map()\n\n  for (const span of spans) {\n    if (span.field != field) continue\n    const ranges = byPath.get(span.path) ?? []\n\n    ranges.push({end: span.end, start: span.start})\n    byPath.set(span.path, ranges)\n  }\n\n  return [...byPath].map(([path, ranges]) => ({path, ranges}))\n}\n\n/**\n * Renders the shared capture runtime and mapped per-module semantic Swift.\n * @param {ReturnType<typeof preflightIosApplication>} prepared - Fully preflighted application.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact[]} Ordered semantic artifacts.\n */\nfunction renderSemanticArtifacts(prepared) {\n  const paths = prepared.modulePaths\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 = [{\n    content: iosSwiftRuntime,\n    contentKind: \"text\",\n    mediaType: \"text/x-swift\",\n    ownership: \"generated\",\n    path: \"Sources/Generated/SemantifoldRuntime.swift\",\n    provenance: {\n      kind: \"synthetic\",\n      reason: \"Shared iOS application output capture and exact Swift scalar support.\",\n      relatedOrigins: []\n    },\n    role: \"support\"\n  }]\n\n  for (const module of prepared.modules) {\n    const moduleId = /** @type {string} */ (Reflect.get(module, \"id\"))\n    const filename = /** @type {string} */ (paths.get(moduleId))\n    const writer = new SourceWriter({\n      filename,\n      language: \"swift\",\n      module,\n      program: prepared.program,\n      programPaths: paths,\n      sources: prepared.sources\n    })\n\n    emitSemanticModule(writer, module, moduleId, moduleId == prepared.program.entryModule, declarations)\n    const mapping = finalizeMapping(writer.finish())\n\n    artifacts.push({\n      content: mapping.generated.content,\n      contentKind: \"text\",\n      mediaType: \"text/x-swift\",\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 * Produces all project paths referenced by the Xcode model.\n * @param {ReturnType<typeof preflightIosApplication>} prepared - Prepared application.\n * @returns {{appSources: string[], assets: string[], infoPlist: string, unitTest: string, uiTest: string, xcconfig: string}} Paths.\n */\nfunction applicationArtifactPaths(prepared) {\n  const {productName: product, resourceRoot, sourceRoot} = prepared.configuration\n\n  return {\n    appSources: [\n      `${sourceRoot}/Generated/SemantifoldRuntime.swift`,\n      ...prepared.modulePaths.values(),\n      `${sourceRoot}/Application/App.swift`,\n      `${sourceRoot}/Application/SemantifoldBridge.swift`,\n      `${sourceRoot}/Application/SemantifoldOutputView.swift`\n    ],\n    assets: [resourceRoot, ...prepared.assets.map(({path}) => path)],\n    infoPlist: \"Configuration/Info.plist\",\n    unitTest: `Tests/${product}Tests.swift`,\n    uiTest: `UITests/${product}UITests.swift`,\n    xcconfig: \"Configuration/Base.xcconfig\"\n  }\n}\n\n/**\n * Derives collision-checked uppercase 24-hex Xcode object IDs from normalized identities.\n * @param {readonly string[]} identities - Complete ordered object identities.\n * @param {(identity: string) => string} [digest] - Test-only digest seam; production uses built-in SHA-256.\n * @returns {Map<string, string>} Object ID by full input identity.\n */\nexport function allocateXcodeObjectIds(identities, digest = identity => createHash(\"sha256\").update(identity).digest(\"hex\")) {\n  const result = new Map()\n  const fullIdentities = new Map()\n\n  for (const identity of identities) {\n    if (typeof identity != \"string\" || identity.length == 0 || result.has(identity)) {\n      throw new SemantifoldDiagnostic({code: \"XCODE_ID_COLLISION\", language: \"ios\",\n        message: \"Xcode object identities must be unique non-empty strings.\"})\n    }\n    const normalized = identity.normalize(\"NFC\")\n    const fullDigest = digest(normalized)\n\n    if (!/^[0-9a-fA-F]{64}$/u.test(fullDigest)) {\n      throw new SemantifoldDiagnostic({code: \"XCODE_ID_COLLISION\", language: \"ios\",\n        message: `Xcode object identity '${identity}' did not produce a full SHA-256 digest.`})\n    }\n    const objectId = fullDigest.slice(0, 24).toUpperCase()\n    const previous = fullIdentities.get(objectId)\n\n    if (previous !== undefined && previous != normalized) {\n      throw new SemantifoldDiagnostic({code: \"XCODE_ID_COLLISION\", language: \"ios\",\n        message: `Xcode object identities '${previous}' and '${normalized}' collide at '${objectId}'.`})\n    }\n    fullIdentities.set(objectId, normalized)\n    result.set(identity, objectId)\n  }\n\n  return result\n}\n\n/**\n * Renders the smallest deterministic Xcode application/unit/UI-test project model.\n * Platform execution remains deferred until the repository has a qualified Apple lane.\n * @param {ReturnType<typeof preflightIosApplication>} prepared - Prepared application.\n * @param {ReturnType<typeof applicationArtifactPaths>} paths - Complete owned paths.\n * @returns {RenderedConfigurationText} Canonical LF project file and causal configuration spans.\n */\nfunction renderPbxProject(prepared, paths) {\n  const configuration = prepared.configuration\n  const product = configuration.productName\n  const resourceRoot = configuration.resourceRoot\n  const sourceRoot = configuration.sourceRoot\n  const identities = [\n    \"project\", \"group:main\", \"group:sources\", \"group:generated\", \"group:application\", \"group:configuration\",\n    \"group:tests\", \"group:uitests\", \"group:products\", \"target:app\", \"target:tests\", \"target:uitests\",\n    \"phase:app:sources\", \"phase:app:resources\", \"phase:app:frameworks\", \"phase:tests:sources\", \"phase:tests:resources\",\n    \"phase:tests:frameworks\", \"phase:uitests:sources\", \"phase:uitests:resources\", \"phase:uitests:frameworks\",\n    \"product:app\", \"product:tests\", \"product:uitests\", \"proxy:tests:app\", \"proxy:uitests:app\",\n    \"dependency:tests:app\", \"dependency:uitests:app\",\n    \"config-list:project\", \"config-list:app\", \"config-list:tests\", \"config-list:uitests\",\n    \"config:project:debug\", \"config:project:release\", \"config:app:debug\", \"config:app:release\",\n    \"config:tests:debug\", \"config:tests:release\", \"config:uitests:debug\", \"config:uitests:release\",\n    `file:${paths.xcconfig}`, `file:${paths.infoPlist}`, `file:${resourceRoot}`,\n    `file:${paths.unitTest}`, `file:${paths.uiTest}`,\n    ...paths.appSources.flatMap(path => [`file:${path}`, `build:app:${path}`]),\n    `build:app:${resourceRoot}`, `build:tests:${paths.unitTest}`, `build:uitests:${paths.uiTest}`\n  ]\n  const ids = allocateXcodeObjectIds(identities)\n  /**\n   * Looks up one planned Xcode identity.\n   * @param {string} identity - Planned identity.\n   * @returns {string} Allocated object ID.\n   */\n  const id = identity => {\n    const value = ids.get(identity)\n\n    if (!value) throw new TypeError(`Missing planned Xcode identity '${identity}'.`)\n\n    return value\n  }\n  /** @type {Map<string, {identity: string, body: ConfigurationLine[]}[]>} */\n  const sections = new Map()\n  /**\n   * Adds an object to one PBX section.\n   * @param {string} section - PBX section.\n   * @param {string} identity - Object identity.\n   * @param {ConfigurationLine[]} body - Object fields.\n   */\n  const add = (section, identity, body) => {\n    const entries = sections.get(section) ?? []\n\n    entries.push({body, identity})\n    sections.set(section, entries)\n  }\n  /**\n   * Renders PBX list values.\n   * @param {string[]} values - PBX list values.\n   * @returns {string} Rendered list body.\n   */\n  const list = values => values.map(value => `\\t\\t\\t\\t${value},`).join(\"\\n\")\n  /**\n   * Produces a stable sorted copy.\n   * @param {string[]} values - Values to sort.\n   * @returns {string[]} Stable sorted copy.\n   */\n  const sorted = values => [...values].sort((left, right) => left < right ? -1 : left > right ? 1 : 0)\n\n  for (const path of paths.appSources) {\n    add(\"PBXBuildFile\", `build:app:${path}`, [\"isa = PBXBuildFile;\", `fileRef = ${id(`file:${path}`)};`])\n    add(\"PBXFileReference\", `file:${path}`, [\"isa = PBXFileReference;\", \"lastKnownFileType = sourcecode.swift;\",\n      [\"path = \", ...pbxConfigurationPath(configuration, path), \";\"], \"sourceTree = SOURCE_ROOT;\"])\n  }\n  add(\"PBXBuildFile\", `build:app:${resourceRoot}`, [\"isa = PBXBuildFile;\", `fileRef = ${id(`file:${resourceRoot}`)};`])\n  add(\"PBXBuildFile\", `build:tests:${paths.unitTest}`, [\"isa = PBXBuildFile;\", `fileRef = ${id(`file:${paths.unitTest}`)};`])\n  add(\"PBXBuildFile\", `build:uitests:${paths.uiTest}`, [\"isa = PBXBuildFile;\", `fileRef = ${id(`file:${paths.uiTest}`)};`])\n  add(\"PBXContainerItemProxy\", \"proxy:tests:app\", [\"isa = PBXContainerItemProxy;\", `containerPortal = ${id(\"project\")};`,\n    \"proxyType = 1;\", `remoteGlobalIDString = ${id(\"target:app\")};`,\n    [\"remoteInfo = \\\"\", configurationFragment(\"productName\", product), \"\\\";\"]])\n  add(\"PBXContainerItemProxy\", \"proxy:uitests:app\", [\"isa = PBXContainerItemProxy;\", `containerPortal = ${id(\"project\")};`,\n    \"proxyType = 1;\", `remoteGlobalIDString = ${id(\"target:app\")};`,\n    [\"remoteInfo = \\\"\", configurationFragment(\"productName\", product), \"\\\";\"]])\n  add(\"PBXFileReference\", `file:${paths.xcconfig}`, [\"isa = PBXFileReference;\", \"lastKnownFileType = text.xcconfig;\",\n    `path = ${pbxString(paths.xcconfig)};`, \"sourceTree = SOURCE_ROOT;\"])\n  add(\"PBXFileReference\", `file:${paths.infoPlist}`, [\"isa = PBXFileReference;\", \"lastKnownFileType = text.plist.xml;\",\n    `path = ${pbxString(paths.infoPlist)};`, \"sourceTree = SOURCE_ROOT;\"])\n  add(\"PBXFileReference\", `file:${resourceRoot}`, [\"isa = PBXFileReference;\", \"lastKnownFileType = folder.assetcatalog;\",\n    [\"path = \", configurationFragment(\"resourceRoot\", resourceRoot), \";\"], \"sourceTree = SOURCE_ROOT;\"])\n  add(\"PBXFileReference\", `file:${paths.unitTest}`, [\"isa = PBXFileReference;\", \"lastKnownFileType = sourcecode.swift;\",\n    [\"path = \", ...pbxConfigurationPath(configuration, paths.unitTest), \";\"], \"sourceTree = SOURCE_ROOT;\"])\n  add(\"PBXFileReference\", `file:${paths.uiTest}`, [\"isa = PBXFileReference;\", \"lastKnownFileType = sourcecode.swift;\",\n    [\"path = \", ...pbxConfigurationPath(configuration, paths.uiTest), \";\"], \"sourceTree = SOURCE_ROOT;\"])\n  add(\"PBXFileReference\", \"product:app\", [\"isa = PBXFileReference;\", \"explicitFileType = wrapper.application;\", \"includeInIndex = 0;\",\n    [\"path = \\\"\", configurationFragment(\"productName\", product), \".app\\\";\"], \"sourceTree = BUILT_PRODUCTS_DIR;\"])\n  add(\"PBXFileReference\", \"product:tests\", [\"isa = PBXFileReference;\", \"explicitFileType = wrapper.cfbundle;\", \"includeInIndex = 0;\",\n    [\"path = \\\"\", configurationFragment(\"productName\", product), \"Tests.xctest\\\";\"], \"sourceTree = BUILT_PRODUCTS_DIR;\"])\n  add(\"PBXFileReference\", \"product:uitests\", [\"isa = PBXFileReference;\", \"explicitFileType = wrapper.cfbundle;\", \"includeInIndex = 0;\",\n    [\"path = \\\"\", configurationFragment(\"productName\", product), \"UITests.xctest\\\";\"], \"sourceTree = BUILT_PRODUCTS_DIR;\"])\n\n  const generatedRefs = sorted(paths.appSources.filter(path => path.startsWith(`${sourceRoot}/Generated/`))).map(path => id(`file:${path}`))\n  const applicationRefs = sorted(paths.appSources.filter(path => path.startsWith(`${sourceRoot}/Application/`))).map(path => id(`file:${path}`))\n\n  add(\"PBXGroup\", \"group:main\", [\"isa = PBXGroup;\", `children = (\\n${list([\n    id(\"group:configuration\"), id(\"group:sources\"), id(`file:${resourceRoot}`), id(\"group:tests\"), id(\"group:uitests\"),\n    id(\"group:products\")\n  ])}\\n\\t\\t\\t);`, \"sourceTree = \\\"<group>\\\";\"])\n  add(\"PBXGroup\", \"group:sources\", [\"isa = PBXGroup;\", `children = (\\n${list([id(\"group:application\"), id(\"group:generated\")])}\\n\\t\\t\\t);`,\n    [\"name = \", configurationFragment(\"sourceRoot\", sourceRoot), \";\"], \"sourceTree = \\\"<group>\\\";\"])\n  add(\"PBXGroup\", \"group:generated\", [\"isa = PBXGroup;\", `children = (\\n${list(generatedRefs)}\\n\\t\\t\\t);`,\n    \"name = Generated;\", \"sourceTree = \\\"<group>\\\";\"])\n  add(\"PBXGroup\", \"group:application\", [\"isa = PBXGroup;\", `children = (\\n${list(applicationRefs)}\\n\\t\\t\\t);`,\n    \"name = Application;\", \"sourceTree = \\\"<group>\\\";\"])\n  add(\"PBXGroup\", \"group:configuration\", [\"isa = PBXGroup;\", `children = (\\n${list([id(`file:${paths.xcconfig}`), id(`file:${paths.infoPlist}`)])}\\n\\t\\t\\t);`,\n    \"name = Configuration;\", \"sourceTree = \\\"<group>\\\";\"])\n  add(\"PBXGroup\", \"group:tests\", [\"isa = PBXGroup;\", `children = (\\n${list([id(`file:${paths.unitTest}`)])}\\n\\t\\t\\t);`,\n    \"name = Tests;\", \"sourceTree = \\\"<group>\\\";\"])\n  add(\"PBXGroup\", \"group:uitests\", [\"isa = PBXGroup;\", `children = (\\n${list([id(`file:${paths.uiTest}`)])}\\n\\t\\t\\t);`,\n    \"name = UITests;\", \"sourceTree = \\\"<group>\\\";\"])\n  add(\"PBXGroup\", \"group:products\", [\"isa = PBXGroup;\", `children = (\\n${list([id(\"product:app\"), id(\"product:tests\"), id(\"product:uitests\")])}\\n\\t\\t\\t);`,\n    \"name = Products;\", \"sourceTree = \\\"<group>\\\";\"])\n\n  addNativeTarget(add, id, configuration, \"target:app\", \"\", \"com.apple.product-type.application\", \"product:app\",\n    \"config-list:app\", [\"phase:app:sources\", \"phase:app:frameworks\", \"phase:app:resources\"], [])\n  addNativeTarget(add, id, configuration, \"target:tests\", \"Tests\", \"com.apple.product-type.bundle.unit-test\", \"product:tests\",\n    \"config-list:tests\", [\"phase:tests:sources\", \"phase:tests:frameworks\", \"phase:tests:resources\"], [\"dependency:tests:app\"])\n  addNativeTarget(add, id, configuration, \"target:uitests\", \"UITests\", \"com.apple.product-type.bundle.ui-testing\", \"product:uitests\",\n    \"config-list:uitests\", [\"phase:uitests:sources\", \"phase:uitests:frameworks\", \"phase:uitests:resources\"], [\"dependency:uitests:app\"])\n  add(\"PBXProject\", \"project\", [\"isa = PBXProject;\", \"attributes = { BuildIndependentTargetsInParallel = YES; };\",\n    `buildConfigurationList = ${id(\"config-list:project\")};`, \"developmentRegion = en;\", \"hasScannedForEncodings = 0;\",\n    \"knownRegions = ( en, Base, );\", `mainGroup = ${id(\"group:main\")};`, `productRefGroup = ${id(\"group:products\")};`,\n    \"projectDirPath = \\\"\\\";\", \"projectRoot = \\\"\\\";\",\n    `targets = (\\n${list([id(\"target:app\"), id(\"target:tests\"), id(\"target:uitests\")])}\\n\\t\\t\\t);`])\n\n  addBuildPhase(add, id, \"PBXFrameworksBuildPhase\", \"phase:app:frameworks\", [])\n  addBuildPhase(add, id, \"PBXResourcesBuildPhase\", \"phase:app:resources\", [`build:app:${resourceRoot}`])\n  addBuildPhase(add, id, \"PBXSourcesBuildPhase\", \"phase:app:sources\", sorted(paths.appSources).map(path => `build:app:${path}`))\n  for (const target of [\"tests\", \"uitests\"]) {\n    addBuildPhase(add, id, \"PBXFrameworksBuildPhase\", `phase:${target}:frameworks`, [])\n    addBuildPhase(add, id, \"PBXResourcesBuildPhase\", `phase:${target}:resources`, [])\n  }\n  addBuildPhase(add, id, \"PBXSourcesBuildPhase\", \"phase:tests:sources\", [`build:tests:${paths.unitTest}`])\n  addBuildPhase(add, id, \"PBXSourcesBuildPhase\", \"phase:uitests:sources\", [`build:uitests:${paths.uiTest}`])\n  add(\"PBXTargetDependency\", \"dependency:tests:app\", [\"isa = PBXTargetDependency;\", `target = ${id(\"target:app\")};`,\n    `targetProxy = ${id(\"proxy:tests:app\")};`])\n  add(\"PBXTargetDependency\", \"dependency:uitests:app\", [\"isa = PBXTargetDependency;\", `target = ${id(\"target:app\")};`,\n    `targetProxy = ${id(\"proxy:uitests:app\")};`])\n\n  for (const owner of [\"project\", \"app\", \"tests\", \"uitests\"]) {\n    for (const variant of [\"debug\", \"release\"]) {\n      const settings = buildSettings(owner, variant, configuration, paths)\n\n      add(\"XCBuildConfiguration\", `config:${owner}:${variant}`, [\"isa = XCBuildConfiguration;\",\n        `baseConfigurationReference = ${id(`file:${paths.xcconfig}`)};`, [\"buildSettings = {\\n\", ...settings, \"\\n\\t\\t\\t};\"],\n        `name = ${variant == \"debug\" ? \"Debug\" : \"Release\"};`])\n    }\n    add(\"XCConfigurationList\", `config-list:${owner}`, [\"isa = XCConfigurationList;\",\n      `buildConfigurations = (\\n${list([id(`config:${owner}:debug`), id(`config:${owner}:release`)])}\\n\\t\\t\\t);`,\n      \"defaultConfigurationIsVisible = 0;\", \"defaultConfigurationName = Release;\"])\n  }\n\n  const order = [\"PBXBuildFile\", \"PBXContainerItemProxy\", \"PBXFileReference\", \"PBXFrameworksBuildPhase\", \"PBXGroup\",\n    \"PBXNativeTarget\", \"PBXProject\", \"PBXResourcesBuildPhase\", \"PBXSourcesBuildPhase\", \"PBXTargetDependency\",\n    \"XCBuildConfiguration\", \"XCConfigurationList\"]\n  const writer = new ConfigurationTextWriter()\n\n  writer.append(\"// !$*UTF8*$!\\n{\\n\\tarchiveVersion = 1;\\n\\tclasses = {};\\n\\tobjectVersion = 56;\\n\\tobjects = {\\n\")\n\n  for (const section of order) {\n    const entries = (sections.get(section) ?? []).sort((left, right) => left.identity < right.identity ? -1 : 1)\n\n    writer.append(`\\n/* Begin ${section} section */\\n`)\n    for (const entry of entries) {\n      writer.append(`\\t\\t${id(entry.identity)} = {\\n`)\n      for (const line of entry.body) {\n        writer.append(\"\\t\\t\\t\")\n        writer.append(line)\n        writer.append(\"\\n\")\n      }\n      writer.append(\"\\t\\t};\\n\")\n    }\n    writer.append(`/* End ${section} section */\\n`)\n  }\n  writer.append(`\\t};\\n\\trootObject = ${id(\"project\")};\\n}\\n`)\n\n  return writer.finish()\n}\n\n/**\n * Adds one native target object to the project model.\n * @param {(section: string, identity: string, body: ConfigurationLine[]) => void} add - Object sink.\n * @param {(identity: string) => string} id - ID lookup.\n * @param {import(\"../semantic/types.js\").IosApplicationConfiguration} configuration - Application configuration.\n * @param {string} identity - Target identity.\n * @param {string} nameSuffix - Target suffix after the product name.\n * @param {string} productType - Product type.\n * @param {string} productReference - Product reference identity.\n * @param {string} configurationList - Configuration list identity.\n * @param {string[]} phases - Phase identities.\n * @param {string[]} dependencies - Dependency identities.\n */\nfunction addNativeTarget(add, id, configuration, identity, nameSuffix, productType, productReference, configurationList,\n  phases, dependencies) {\n  /**\n   * Renders target identity values.\n   * @param {string[]} values - Target identity values.\n   * @returns {string} Rendered target list.\n   */\n  const lines = values => values.map(value => `\\t\\t\\t\\t${id(value)},`).join(\"\\n\")\n  const name = [\"\\\"\", configurationFragment(\"productName\", configuration.productName), `${nameSuffix}\"`]\n\n  add(\"PBXNativeTarget\", identity, [\"isa = PBXNativeTarget;\", `buildConfigurationList = ${id(configurationList)};`,\n    `buildPhases = (\\n${lines(phases)}\\n\\t\\t\\t);`, \"buildRules = ();\", `dependencies = (\\n${lines(dependencies)}\\n\\t\\t\\t);`,\n    [\"name = \", ...name, \";\"], [\"productName = \", ...name, \";\"], `productReference = ${id(productReference)};`,\n    `productType = ${pbxString(productType)};`])\n}\n\n/**\n * Adds one build phase to the project model.\n * @param {(section: string, identity: string, body: ConfigurationLine[]) => void} add - Object sink.\n * @param {(identity: string) => string} id - ID lookup.\n * @param {string} section - Phase ISA.\n * @param {string} identity - Phase identity.\n * @param {string[]} files - Build-file identities.\n */\nfunction addBuildPhase(add, id, section, identity, files) {\n  const lines = files.map(file => `\\t\\t\\t\\t${id(file)},`).join(\"\\n\")\n\n  add(section, identity, [`isa = ${section};`, \"buildActionMask = 2147483647;\", `files = (\\n${lines}\\n\\t\\t\\t);`,\n    \"runOnlyForDeploymentPostprocessing = 0;\"])\n}\n\n/**\n * Renders sorted PBX build settings for one owner and variant.\n * @param {string} owner - Configuration owner.\n * @param {string} variant - Debug or release.\n * @param {import(\"../semantic/types.js\").IosApplicationConfiguration} configuration - Application configuration.\n * @param {ReturnType<typeof applicationArtifactPaths>} paths - Planned paths.\n * @returns {ConfigurationTextPart[]} Sorted PBX build settings.\n */\nfunction buildSettings(owner, variant, configuration, paths) {\n  /** @type {Record<string, ConfigurationTextPart | ConfigurationTextPart[]>} */\n  const values = owner == \"project\" ? {\n    CODE_SIGNING_ALLOWED: \"NO\",\n    CODE_SIGNING_REQUIRED: \"NO\"\n  } : owner == \"app\" ? {\n    GENERATE_INFOPLIST_FILE: \"NO\",\n    INFOPLIST_FILE: pbxString(paths.infoPlist),\n    IPHONEOS_DEPLOYMENT_TARGET: configurationFragment(\"deploymentTarget\", configuration.deploymentTarget),\n    PRODUCT_BUNDLE_IDENTIFIER: configurationFragment(\"bundleIdentifier\", configuration.bundleIdentifier),\n    PRODUCT_MODULE_NAME: configurationFragment(\"moduleName\", configuration.moduleName),\n    PRODUCT_NAME: configurationFragment(\"productName\", configuration.productName),\n    SDKROOT: \"iphoneos\",\n    SUPPORTED_PLATFORMS: pbxString(\"iphoneos iphonesimulator\"),\n    TARGETED_DEVICE_FAMILY: \"1\"\n  } : owner == \"tests\" ? {\n    BUNDLE_LOADER: pbxString(\"$(TEST_HOST)\"),\n    PRODUCT_BUNDLE_IDENTIFIER: [configurationFragment(\"bundleIdentifier\", configuration.bundleIdentifier), \".tests\"],\n    PRODUCT_MODULE_NAME: [configurationFragment(\"moduleName\", configuration.moduleName), \"Tests\"],\n    PRODUCT_NAME: \"$(TARGET_NAME)\",\n    TEST_HOST: [\"\\\"$(BUILT_PRODUCTS_DIR)/\", configurationFragment(\"productName\", configuration.productName),\n      \".app/\", configurationFragment(\"productName\", configuration.productName), \"\\\"\"]\n  } : {\n    PRODUCT_BUNDLE_IDENTIFIER: [configurationFragment(\"bundleIdentifier\", configuration.bundleIdentifier), \".uitests\"],\n    PRODUCT_MODULE_NAME: [configurationFragment(\"moduleName\", configuration.moduleName), \"UITests\"],\n    PRODUCT_NAME: \"$(TARGET_NAME)\",\n    TEST_TARGET_NAME: configurationFragment(\"productName\", configuration.productName)\n  }\n\n  if (variant == \"release\") values.SWIFT_OPTIMIZATION_LEVEL = pbxString(\"-O\")\n\n  /** @type {ConfigurationTextPart[]} */\n  const output = []\n\n  for (const [index, key] of Object.keys(values).sort().entries()) {\n    const value = values[key]\n\n    if (index > 0) output.push(\"\\n\")\n    output.push(`\\t\\t\\t\\t${key} = `)\n    output.push(...(Array.isArray(value) ? value : [value]))\n    output.push(\";\")\n  }\n\n  return output\n}\n\n/**\n * Quotes one PBX scalar.\n * @param {string} value - PBX scalar.\n * @returns {string} Safely quoted PBX scalar.\n */\nfunction pbxString(value) {\n  return JSON.stringify(value)\n}\n\n/**\n * Renders a quoted PBX path while retaining causality for its configured component.\n * @param {import(\"../semantic/types.js\").IosApplicationConfiguration} configuration - Application configuration.\n * @param {string} path - Planned artifact path.\n * @returns {ConfigurationTextPart[]} Quoted PBX path fragments.\n */\nfunction pbxConfigurationPath(configuration, path) {\n  if (path.startsWith(`${configuration.sourceRoot}/`)) {\n    return [\"\\\"\", configurationFragment(\"sourceRoot\", configuration.sourceRoot), path.slice(configuration.sourceRoot.length), \"\\\"\"]\n  }\n  if (path == configuration.resourceRoot) {\n    return [\"\\\"\", configurationFragment(\"resourceRoot\", configuration.resourceRoot), \"\\\"\"]\n  }\n  if (path == `Tests/${configuration.productName}Tests.swift`) {\n    return [\"\\\"Tests/\", configurationFragment(\"productName\", configuration.productName), \"Tests.swift\\\"\"]\n  }\n  if (path == `UITests/${configuration.productName}UITests.swift`) {\n    return [\"\\\"UITests/\", configurationFragment(\"productName\", configuration.productName), \"UITests.swift\\\"\"]\n  }\n\n  return [pbxString(path)]\n}\n\n/**\n * Renders the shared scheme XML.\n * @param {ReturnType<typeof preflightIosApplication>} prepared - Prepared application.\n * @returns {RenderedConfigurationText} Shared scheme XML and causal configuration spans.\n */\nfunction renderSharedScheme(prepared) {\n  const product = prepared.configuration.productName\n  const appId = allocateXcodeObjectIds([\"target:app\"]).get(\"target:app\")\n  const testId = allocateXcodeObjectIds([\"target:tests\"]).get(\"target:tests\")\n  const uiTestId = allocateXcodeObjectIds([\"target:uitests\"]).get(\"target:uitests\")\n  /**\n   * Renders one scheme buildable reference.\n   * @param {string} nameSuffix - Blueprint suffix after product name.\n   * @param {string} buildableSuffix - Product filename suffix.\n   * @param {string | undefined} id - Object ID.\n   * @returns {ConfigurationTextPart[]} XML reference.\n   */\n  const reference = (nameSuffix, buildableSuffix, id) => [`<BuildableReference\n               BuildableIdentifier = \"primary\"\n               BlueprintIdentifier = \"${id}\"\n               BuildableName = \"`, configurationFragment(\"productName\", product), `${buildableSuffix}\"\n               BlueprintName = \"`, configurationFragment(\"productName\", product), `${nameSuffix}\"\n               ReferencedContainer = \"container:`, configurationFragment(\"productName\", product), `.xcodeproj\">\n            </BuildableReference>`]\n  const writer = new ConfigurationTextWriter()\n\n  writer.append(`<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Scheme version=\"1.7\">\n   <BuildAction parallelizeBuildables=\"YES\" buildImplicitDependencies=\"YES\">\n      <BuildActionEntries>\n         <BuildActionEntry buildForTesting=\"YES\" buildForRunning=\"YES\" buildForProfiling=\"YES\" buildForArchiving=\"YES\" buildForAnalyzing=\"YES\">\n            `)\n  writer.append(reference(\"\", \".app\", appId))\n  writer.append(`\n         </BuildActionEntry>\n      </BuildActionEntries>\n   </BuildAction>\n   <TestAction buildConfiguration=\"Debug\" selectedDebuggerIdentifier=\"Xcode.DebuggerFoundation.Debugger.LLDB\" selectedLauncherIdentifier=\"Xcode.DebuggerFoundation.Launcher.LLDB\" shouldUseLaunchSchemeArgsEnv=\"YES\">\n      <Testables>\n         <TestableReference skipped=\"NO\">\n            `)\n  writer.append(reference(\"Tests\", \"Tests.xctest\", testId))\n  writer.append(`\n         </TestableReference>\n         <TestableReference skipped=\"NO\">\n            `)\n  writer.append(reference(\"UITests\", \"UITests.xctest\", uiTestId))\n  writer.append(`\n         </TestableReference>\n      </Testables>\n   </TestAction>\n   <LaunchAction buildConfiguration=\"Debug\" selectedDebuggerIdentifier=\"Xcode.DebuggerFoundation.Debugger.LLDB\" selectedLauncherIdentifier=\"Xcode.DebuggerFoundation.Launcher.LLDB\" launchStyle=\"0\" useCustomWorkingDirectory=\"NO\" ignoresPersistentStateOnLaunch=\"NO\" debugDocumentVersioning=\"YES\" debugServiceExtension=\"internal\" allowLocationSimulation=\"YES\">\n      <BuildableProductRunnable runnableDebuggingMode=\"0\">\n         `)\n  writer.append(reference(\"\", \".app\", appId))\n  writer.append(`\n      </BuildableProductRunnable>\n   </LaunchAction>\n   <ProfileAction buildConfiguration=\"Release\" shouldUseLaunchSchemeArgsEnv=\"YES\" savedToolIdentifier=\"\" useCustomWorkingDirectory=\"NO\" debugDocumentVersioning=\"YES\">\n      <BuildableProductRunnable runnableDebuggingMode=\"0\">\n         `)\n  writer.append(reference(\"\", \".app\", appId))\n  writer.append(`\n      </BuildableProductRunnable>\n   </ProfileAction>\n   <AnalyzeAction buildConfiguration=\"Debug\"/>\n   <ArchiveAction buildConfiguration=\"Release\" revealArchiveInOrganizer=\"YES\"/>\n</Scheme>\n`)\n\n  return writer.finish()\n}\n\n/**\n * Renders the closed unsigned base configuration.\n * @param {import(\"../semantic/types.js\").IosApplicationConfiguration} configuration - Application configuration.\n * @returns {RenderedConfigurationText} Base xcconfig and causal configuration spans.\n */\nfunction renderBaseConfiguration(configuration) {\n  const writer = new ConfigurationTextWriter()\n\n  writer.append(`CODE_SIGNING_ALLOWED = NO\nCODE_SIGNING_REQUIRED = NO\nGENERATE_INFOPLIST_FILE = NO\nIPHONEOS_DEPLOYMENT_TARGET = `)\n  writer.append(configurationFragment(\"deploymentTarget\", configuration.deploymentTarget))\n  writer.append(\"\\nPRODUCT_BUNDLE_IDENTIFIER = \")\n  writer.append(configurationFragment(\"bundleIdentifier\", configuration.bundleIdentifier))\n  writer.append(\"\\nPRODUCT_MODULE_NAME = \")\n  writer.append(configurationFragment(\"moduleName\", configuration.moduleName))\n  writer.append(\"\\nPRODUCT_NAME = \")\n  writer.append(configurationFragment(\"productName\", configuration.productName))\n  writer.append(`\nSDKROOT = iphoneos\nSUPPORTED_PLATFORMS = iphoneos iphonesimulator\nTARGETED_DEVICE_FAMILY = 1\n`)\n\n  return writer.finish()\n}\n\n/**\n * Renders the allowlisted application property list.\n * @param {import(\"../semantic/types.js\").IosApplicationConfiguration} configuration - Application configuration.\n * @returns {RenderedConfigurationText} Property-list XML and causal configuration spans.\n */\nfunction renderInfoPlist(configuration) {\n  const writer = new ConfigurationTextWriter()\n\n  writer.append(`<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n<plist version=\"1.0\">\n<dict>\n  <key>CFBundleDisplayName</key>\n  <string>`)\n  writer.append(configurationFragment(\"displayName\", xmlEscape(configuration.displayName)))\n  writer.append(`</string>\n  <key>CFBundleExecutable</key>\n  <string>$(EXECUTABLE_NAME)</string>\n  <key>CFBundleIdentifier</key>\n  <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>\n  <key>CFBundleInfoDictionaryVersion</key>\n  <string>6.0</string>\n  <key>CFBundleName</key>\n  <string>$(PRODUCT_NAME)</string>\n  <key>CFBundlePackageType</key>\n  <string>APPL</string>\n  <key>CFBundleShortVersionString</key>\n  <string>1.0</string>\n  <key>CFBundleVersion</key>\n  <string>1</string>\n  <key>LSRequiresIPhoneOS</key>\n  <true/>\n  <key>UILaunchScreen</key>\n  <dict/>\n</dict>\n</plist>\n`)\n\n  return writer.finish()\n}\n\n/**\n * Renders pure-logic XCTest source.\n * @param {import(\"../semantic/types.js\").IosApplicationConfiguration} configuration - Application configuration.\n * @returns {RenderedConfigurationText} XCTest source and causal configuration spans.\n */\nfunction renderUnitTests(configuration) {\n  const writer = new ConfigurationTextWriter()\n\n  writer.append(\"import XCTest\\n@testable import \")\n  writer.append(configurationFragment(\"moduleName\", configuration.moduleName))\n  writer.append(\"\\n\\nfinal class \")\n  writer.append(configurationFragment(\"productName\", configuration.productName))\n  writer.append(`Tests: XCTestCase {\n  func testSemanticOutputIsDeterministic() {\n    XCTAssertEqual(SemantifoldBridge.run(), SemantifoldBridge.run())\n  }\n\n  func testOutputSinkPreservesScalarLines() {\n    let output = SemantifoldOutputSink()\n    output.write(Int64(7))\n    output.write(true)\n    output.write(\"é😀\")\n    XCTAssertEqual(output.lines, [\"7\", \"true\", \"é😀\"])\n  }\n}\n`)\n\n  return writer.finish()\n}\n\n/**\n * Renders the accessibility-route XCUI source.\n * @param {import(\"../semantic/types.js\").IosApplicationConfiguration} configuration - Application configuration.\n * @returns {RenderedConfigurationText} XCUI source and causal configuration spans.\n */\nfunction renderUiTests(configuration) {\n  const writer = new ConfigurationTextWriter()\n\n  writer.append(\"import XCTest\\n\\nfinal class \")\n  writer.append(configurationFragment(\"productName\", configuration.productName))\n  writer.append(`UITests: XCTestCase {\n  func testOutputViewIsAccessible() {\n    let application = XCUIApplication()\n    application.launch()\n    XCTAssertTrue(application.staticTexts[\"semantifold-output\"].waitForExistence(timeout: 5))\n  }\n}\n`)\n\n  return writer.finish()\n}\n\n/**\n * Escapes XML text and attribute content.\n * @param {string} value - XML text or attribute 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 * Creates one synthetic text artifact candidate.\n * @param {string} path - Artifact path.\n * @param {import(\"../semantic/types.js\").GeneratedArtifactRole} role - Artifact role.\n * @param {string} content - Exact LF content.\n * @param {string} reason - Provenance reason.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Artifact candidate.\n */\nfunction syntheticText(path, role, content, reason) {\n  return {\n    content,\n    contentKind: \"text\",\n    mediaType: path.endsWith(\".swift\") ? \"text/x-swift\" : path.endsWith(\".json\") ? \"application/json\" :\n      path.endsWith(\".plist\") || path.endsWith(\".xcscheme\") ? \"application/xml\" : \"text/plain\",\n    ownership: \"generated\",\n    path,\n    provenance: {kind: \"synthetic\", reason, relatedOrigins: []},\n    role\n  }\n}\n\n/**\n * Creates a synthetic artifact and transfers its renderer-owned configuration spans to the manifest ledger.\n * @param {string} path - Artifact path.\n * @param {import(\"../semantic/types.js\").GeneratedArtifactRole} role - Artifact role.\n * @param {RenderedConfigurationText} rendered - Rendered content and causal spans.\n * @param {ConfigurationArtifactSpan[]} spans - Application-wide causal span ledger.\n * @param {string} reason - Provenance reason.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Artifact candidate.\n */\nfunction configuredSyntheticText(path, role, rendered, spans, reason) {\n  spans.push(...rendered.configurationSpans.map(span => ({...span, path})))\n\n  return syntheticText(path, role, rendered.content, reason)\n}\n\n/**\n * Serializes recursively sorted canonical JSON with an LF.\n * @param {unknown} value - JSON value.\n * @returns {string} Canonical JSON with LF.\n */\nfunction stringifyCanonicalJson(value) {\n  return `${JSON.stringify(sortJson(value), null, 2)}\\n`\n}\n\n/**\n * Recursively sorts JSON object keys without reordering arrays.\n * @param {unknown} value - JSON value.\n * @returns {unknown} Recursively key-sorted JSON.\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 and snapshots the strict baseline application configuration.\n * Identity and deployment fields intentionally have no defaults without Apple-lane evidence.\n * @param {unknown} candidate - Candidate configuration.\n * @returns {import(\"../semantic/types.js\").IosApplicationConfiguration} Normalized configuration.\n */\nfunction normalizeConfiguration(candidate) {\n  if (!isPlainObject(candidate) || Object.keys(candidate).some(key => !configurationFields.has(key))) {\n    invalidConfiguration(\"iOS application configuration must be a closed plain object.\")\n  }\n  const productName = candidate.productName\n  const moduleName = candidate.moduleName\n  const organizationPrefix = candidate.organizationPrefix\n  const bundleIdentifier = candidate.bundleIdentifier\n  const deploymentTarget = candidate.deploymentTarget\n  const displayName = candidate.displayName\n\n  if (typeof productName != \"string\" || !/^[A-Z][A-Za-z0-9]*$/u.test(productName)) {\n    invalidConfiguration(\"Product name must be an ASCII upper-camel identifier.\")\n  }\n  if (typeof moduleName != \"string\" || !/^[A-Z][A-Za-z0-9]*$/u.test(moduleName)) {\n    invalidConfiguration(\"Module name must be an ASCII upper-camel identifier.\")\n  }\n  if (typeof organizationPrefix != \"string\" || !isReverseDns(organizationPrefix, 2)) {\n    invalidConfiguration(\"Organization prefix must be a lowercase reverse-DNS identity with at least two segments.\")\n  }\n  if (typeof bundleIdentifier != \"string\" || !isReverseDns(bundleIdentifier, 3) ||\n    !bundleIdentifier.startsWith(`${organizationPrefix}.`)) {\n    invalidConfiguration(\"Bundle identifier must extend the exact organization prefix as lowercase reverse DNS.\")\n  }\n  if (typeof deploymentTarget != \"string\" || !/^[1-9][0-9]*\\.(?:0|[1-9][0-9]*)$/u.test(deploymentTarget)) {\n    invalidConfiguration(\"Deployment target must be a caller-supplied canonical major.minor version.\")\n  }\n  if (typeof displayName != \"string\" || displayName.length == 0 || displayName.trim() != displayName ||\n    [...displayName].length > 64 || !hasOnlyUnicodeScalars(displayName) || /\\p{Cc}/u.test(displayName)) {\n    invalidConfiguration(\"Display name must be a non-empty single-line Unicode scalar string of at most 64 characters.\")\n  }\n  const sourceRoot = candidate.sourceRoot ?? \"Sources\"\n  const resourceRoot = candidate.resourceRoot ?? \"Assets.xcassets\"\n  const lifecycle = candidate.lifecycle ?? \"swiftui\"\n\n  if (sourceRoot != \"Sources\" || !isSafeArtifactPath(sourceRoot)) invalidConfiguration(\"The supported source root is exactly 'Sources'.\")\n  if (resourceRoot != \"Assets.xcassets\" || !isSafeArtifactPath(resourceRoot)) {\n    invalidConfiguration(\"The supported resource root is exactly 'Assets.xcassets'.\")\n  }\n  if (lifecycle != \"swiftui\") invalidConfiguration(\"The supported application lifecycle is exactly 'swiftui'.\")\n  const infoPlist = candidate.infoPlist ?? {}\n\n  if (!isPlainObject(infoPlist) || Object.keys(infoPlist).length > 0) {\n    invalidConfiguration(\"The baseline caller Info.plist extension allowlist is empty.\")\n  }\n  const permissions = emptyConfigurationSet(candidate.permissions, \"permissions\")\n  const entitlements = emptyConfigurationSet(candidate.entitlements, \"entitlements\")\n  const privacyDeclarations = emptyConfigurationSet(candidate.privacyDeclarations, \"privacy declarations\")\n  const capabilities = emptyConfigurationSet(candidate.capabilities, \"capabilities\")\n\n  return {\n    bundleIdentifier,\n    capabilities,\n    deploymentTarget,\n    displayName,\n    entitlements,\n    infoPlist: {},\n    lifecycle: \"swiftui\",\n    moduleName,\n    organizationPrefix,\n    permissions,\n    privacyDeclarations,\n    productName,\n    resourceRoot: \"Assets.xcassets\",\n    sourceRoot: \"Sources\"\n  }\n}\n\n/**\n * Validates one optional closed empty configuration set.\n * @param {unknown} candidate - Optional closed set.\n * @param {string} label - Diagnostic label.\n * @returns {never[]} Empty snapshot.\n */\nfunction emptyConfigurationSet(candidate, label) {\n  if (candidate === undefined) return []\n  if (!isDenseArray(candidate) || candidate.length != 0) invalidConfiguration(`The baseline ${label} set must be empty.`)\n\n  return []\n}\n\n/**\n * Tests one canonical lowercase reverse-DNS identity.\n * @param {string} value - Candidate identity.\n * @param {number} segments - Minimum segments.\n * @returns {boolean} Validity.\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) && !part.endsWith(\"-\"))\n}\n\n/**\n * Validates, hashes, snapshots, and canonically sorts caller assets.\n * @param {unknown} candidate - Candidate asset array.\n * @param {string} resourceRoot - Exact resource root.\n * @returns {import(\"../semantic/types.js\").IosApplicationAssetInput[]} Normalized assets.\n */\nfunction normalizeAssets(candidate, resourceRoot) {\n  if (candidate === undefined) return []\n  if (!isDenseArray(candidate)) invalidAsset(\"Application assets must be a dense array.\")\n  /** @type {import(\"../semantic/types.js\").IosApplicationAssetInput[]} */\n  const assets = []\n\n  for (let index = 0; index < candidate.length; index += 1) {\n    const asset = candidate[index]\n\n    if (!isPlainObject(asset) || Object.keys(asset).some(key => !assetFields.has(key)) ||\n      Object.keys(asset).length != assetFields.size) invalidAsset(`Asset ${index} must use the closed asset schema.`)\n    const path = asset.path\n    const content = asset.content\n    const mediaType = asset.mediaType\n    const sha256 = asset.sha256\n\n    if (!isSafeArtifactPath(path) || !path.startsWith(`${resourceRoot}/`) || path == `${resourceRoot}/Contents.json`) {\n      invalidAsset(`Asset ${index} requires a safe path below '${resourceRoot}'.`)\n    }\n    if (typeof content != \"string\" && !(content instanceof Uint8Array) ||\n      typeof content == \"string\" && (content.length == 0 || !hasOnlyUnicodeScalars(content)) ||\n      content instanceof Uint8Array && content.byteLength == 0) invalidAsset(`Asset '${path}' requires non-empty exact content.`)\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, mediaType, path, sha256})\n  }\n  assets.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0)\n\n  return assets\n}\n\n/**\n * Creates an exact text or binary asset artifact.\n * @param {import(\"../semantic/types.js\").IosApplicationAssetInput} asset - Validated asset.\n * @returns {import(\"../semantic/types.js\").GeneratedSetArtifact} Artifact candidate.\n */\nfunction assetArtifact(asset) {\n  if (typeof asset.content == \"string\") return {\n    content: asset.content,\n    contentKind: \"text\",\n    mediaType: asset.mediaType,\n    ownership: \"generated\",\n    path: asset.path,\n    provenance: {kind: \"synthetic\", reason: `Exact caller-provided iOS asset (sha256:${asset.sha256}).`, relatedOrigins: []},\n    role: \"resource\"\n  }\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.path,\n    provenance: {kind: \"bytes\", mapping: createByteMapping({\n      byteLength: content.byteLength,\n      path: asset.path,\n      ranges: [{\n        generated: {end: content.byteLength, start: 0},\n        origin: {kind: \"synthetic\", reason: `Exact caller-provided iOS asset (sha256:${asset.sha256}).`, relatedOrigins: []},\n        role: \"asset\"\n      }]\n    })},\n    role: \"resource\"\n  }\n}\n\n/**\n * Throws a configuration diagnostic.\n * @param {string} message - Failure detail.\n * @returns {never} Always throws.\n */\nfunction invalidConfiguration(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_CONFIGURATION\", language: \"ios\", message})\n}\n\n/**\n * Throws an asset diagnostic.\n * @param {string} message - Failure detail.\n * @returns {never} Always throws.\n */\nfunction invalidAsset(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_ASSET\", language: \"ios\", message})\n}\n\n/**\n * Throws an application-path diagnostic.\n * @param {string} message - Failure detail.\n * @returns {never} Always throws.\n */\nfunction invalidPath(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_APPLICATION_PATH\", language: \"ios\", message})\n}\n\n/**\n * Emits one backend-namespaced semantic module.\n * @param {SourceWriter} writer - Source-aware generated Swift writer.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Prepared semantic module.\n * @param {string} moduleId - Stable project module identity.\n * @param {boolean} entry - Whether this module owns the semantic entry.\n * @param {Map<string | undefined, {declaration: import(\"../semantic/types.js\").FunctionDeclaration, moduleId: string}>} declarations - Resolved functions.\n */\nfunction emitSemanticModule(writer, module, moduleId, entry, declarations) {\n  const namespace = `SemantifoldModule${moduleName(moduleId)}`\n\n  writer.synthetic(`enum ${namespace} {\\n`, \"iOS semantic module namespace\", [module], [\"\"])\n  module.functions.forEach((declaration, functionIndex) => {\n    const path = `/functions/${functionIndex}`\n\n    writer.synthetic(\"  static \", \"iOS namespaced function scaffold\", [declaration], [path])\n    writer.mapped(\"func\", {mappingKind: \"anchor\", node: declaration, path})\n    writer.synthetic(\" \", \"declaration spacing\", [declaration], [path])\n    writer.mapped(declaration.name, {mappingKind: \"exact\", node: declaration, path, role: \"name\"})\n    writer.synthetic(\"(\", \"function parameter scaffold\", [declaration], [path])\n    declaration.parameters.forEach((parameter, parameterIndex) => {\n      const parameterPath = `${path}/parameters/${parameterIndex}`\n\n      if (parameterIndex) writer.synthetic(\", \", \"parameter separator\", [parameter], [parameterPath])\n      writer.synthetic(\"_ \", \"unlabeled Swift parameter scaffold\", [parameter], [parameterPath])\n      writer.mapped(parameter.name, {mappingKind: \"exact\", node: parameter, path: parameterPath, role: \"name\"})\n      writer.synthetic(\": \", \"parameter annotation scaffold\", [parameter], [parameterPath])\n      writer.mapped(emitScalarType(\"swift\", parameter.type), {mappingKind: \"exact\", node: parameter.type,\n        path: `${parameterPath}/type`, role: \"type\"})\n    })\n    writer.synthetic(\", _ semantifold_output: SemantifoldOutputSink) -> \", \"shared iOS output sink parameter\", [declaration], [path])\n    writer.mapped(emitScalarType(\"swift\", declaration.returnType), {mappingKind: \"exact\", node: declaration.returnType,\n      path: `${path}/returnType`, role: \"type\"})\n    writer.synthetic(\" {\\n\", \"Swift function body scaffold\", [declaration], [path])\n    emitBlock(writer, declaration.body, \"    \", `${path}/body`, declarations)\n    writer.synthetic(\"  }\\n\", \"Swift function body scaffold\", [declaration], [path])\n  })\n  if (entry) {\n    writer.synthetic(\"  static func semantifoldEntry() -> [String] {\\n\", \"iOS semantic entry scaffold\", [module.entryPoint], [\"/entryPoint\"])\n    writer.synthetic(\"    let semantifold_output = SemantifoldOutputSink()\\n\", \"shared iOS output sink allocation\",\n      [module.entryPoint], [\"/entryPoint\"])\n    emitBlock(writer, module.entryPoint.body, \"    \", \"/entryPoint/body\", declarations)\n    writer.synthetic(\"    return semantifold_output.lines\\n\", \"iOS semantic output return\", [module.entryPoint], [\"/entryPoint\"])\n    writer.synthetic(\"  }\\n\", \"iOS semantic entry scaffold\", [module.entryPoint], [\"/entryPoint\"])\n  }\n  writer.synthetic(\"}\\n\", \"iOS semantic module namespace\", [module], [\"\"])\n}\n\n/**\n * Emits a validated ordered semantic block.\n * @param {SourceWriter} writer - Source writer.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @param {string} indent - Current indentation.\n * @param {string} path - Block occurrence path.\n * @param {Map<string | undefined, {declaration: import(\"../semantic/types.js\").FunctionDeclaration, moduleId: string}>} declarations - Resolved functions.\n */\nfunction emitBlock(writer, block, indent, path, declarations) {\n  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`, declarations))\n}\n\n/**\n * Emits one Swift statement through the shared capture sink.\n * @param {SourceWriter} writer - Source writer.\n * @param {import(\"../semantic/types.js\").Statement} statement - Validated statement.\n * @param {string} indent - Current indentation.\n * @param {string} path - Statement occurrence path.\n * @param {Map<string | undefined, {declaration: import(\"../semantic/types.js\").FunctionDeclaration, moduleId: string}>} declarations - Resolved functions.\n */\nfunction emitStatement(writer, statement, indent, path, declarations) {\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  if (statement.kind == \"LocalDeclaration\") {\n    writer.mapped(statement.mutable ? \"var\" : \"let\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\" \", \"declaration spacing\", [statement], [path])\n    writer.mapped(statement.name, {mappingKind: \"exact\", node: statement, path, role: \"name\"})\n    writer.synthetic(\": \", \"local annotation scaffold\", [statement], [path])\n    writer.mapped(emitScalarType(\"swift\", statement.type), {mappingKind: \"exact\", node: statement.type,\n      path: `${path}/type`, role: \"type\"})\n    writer.synthetic(\" = \", \"assignment spacing\", [statement], [path])\n    emitExpression(writer, statement.initializer, `${path}/initializer`, declarations)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    if (statement.mutable) writer.synthetic(`${indent}semantifold_keep_mutable(&${statement.name})\\n`,\n      \"Swift mutable-local warning marker\", [statement], [path])\n    return\n  }\n  if (statement.kind == \"AssignmentStatement\") {\n    writer.mapped(statement.target.name, {mappingKind: \"exact\", node: statement.target, path: `${path}/target`, role: \"name\"})\n    writer.synthetic(\" = \", \"assignment spacing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, declarations)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n  if (statement.kind == \"ReturnStatement\") {\n    if (!statement.expression) throw new TypeError(\"iOS Swift bare return reached emission.\")\n    writer.mapped(\"return\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\" \", \"return spacing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, declarations)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n  if (statement.kind == \"PrintStatement\") {\n    writer.synthetic(\"semantifold_output.write(\", \"iOS output capture\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, declarations)\n    writer.synthetic(\")\\n\", \"iOS output capture\", [statement], [path])\n    return\n  }\n  if (statement.kind != \"IfStatement\") throw new TypeError(\"Unsupported iOS Swift statement reached emission.\")\n  writer.mapped(\"if\", {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\" \", \"conditional spacing\", [statement], [path])\n  emitExpression(writer, statement.condition, `${path}/condition`, declarations)\n  writer.synthetic(\" {\\n\", \"Swift conditional scaffold\", [statement.consequent], [`${path}/consequent`])\n  emitBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`, declarations)\n  writer.synthetic(`${indent}}`, \"Swift conditional scaffold\", [statement.consequent], [`${path}/consequent`])\n  if (statement.alternate) {\n    writer.synthetic(\" else {\\n\", \"Swift alternate scaffold\", [statement.alternate], [`${path}/alternate`])\n    emitBlock(writer, statement.alternate, `${indent}  `, `${path}/alternate`, declarations)\n    writer.synthetic(`${indent}}`, \"Swift alternate scaffold\", [statement.alternate], [`${path}/alternate`])\n  }\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n}\n\n/**\n * Emits one validated Tasks 001-004 expression and threads the shared sink through calls.\n * @param {SourceWriter} writer - Source writer.\n * @param {import(\"../semantic/types.js\").Expression} expression - Semantic expression.\n * @param {string} path - Expression occurrence path.\n * @param {Map<string | undefined, {declaration: import(\"../semantic/types.js\").FunctionDeclaration, moduleId: string}>} declarations - Resolved functions.\n */\nfunction emitExpression(writer, expression, path, declarations) {\n  if (expression.kind == \"IdentifierExpression\") {\n    writer.mapped(expression.name, {mappingKind: \"exact\", node: expression, path, role: \"name\"})\n    return\n  }\n  if (expression.kind == \"IntegerLiteral\") {\n    writer.mapped(String(expression.value), {mappingKind: \"exact\", node: expression, path, role: \"literal\"})\n    return\n  }\n  if (expression.kind == \"BooleanLiteral\") {\n    writer.mapped(expression.value ? \"true\" : \"false\", {mappingKind: \"exact\", node: expression, path, role: \"literal\"})\n    return\n  }\n  if (expression.kind == \"StringLiteral\") {\n    writer.mapped(emitStringLiteral(\"swift\", expression.value), {mappingKind: \"exact\", node: expression, path, role: \"literal\"})\n    return\n  }\n  if (expression.kind == \"CallExpression\") {\n    const resolved = declarations.get(expression.resolution?.declarationId)\n\n    if (!resolved) throw new TypeError(`Unknown validated iOS function '${expression.resolution?.declarationId}'.`)\n    writer.mapped(`SemantifoldModule${moduleName(resolved.moduleId)}.${resolved.declaration.name}`, {\n      mappingKind: \"exact\", name: expression.callee, node: expression, path, role: \"callee\"\n    })\n    writer.synthetic(\"(\", \"iOS semantic function call\", [expression], [path])\n    expression.arguments.forEach((argument, index) => {\n      if (index) writer.synthetic(\", \", \"argument separator\", [expression], [path])\n      emitExpression(writer, argument, `${path}/arguments/${index}`, declarations)\n    })\n    writer.synthetic(\", semantifold_output)\", \"shared iOS output sink argument\", [expression], [path])\n    return\n  }\n  if (expression.kind == \"UnaryExpression\") {\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: expression, path})\n    writer.mapped(unaryOperations[expression.operation], {mappingKind: \"exact\", node: expression, path, role: \"operator\"})\n    emitExpression(writer, expression.operand, `${path}/operand`, declarations)\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: expression, path})\n    return\n  }\n  if (expression.kind != \"BinaryExpression\") throw new TypeError(\"Unsupported iOS Swift expression reached emission.\")\n  if (expression.operation == \"StringEqual\" || expression.operation == \"StringNotEqual\") {\n    writer.mapped(expression.operation == \"StringEqual\" ? \"semantifold_string_equal\" : \"semantifold_string_not_equal\",\n      {mappingKind: \"exact\", node: expression, path, role: \"operator\"})\n    writer.synthetic(\"(\", \"Swift scalar-equality helper call\", [expression], [path])\n    emitExpression(writer, expression.left, `${path}/left`, declarations)\n    writer.synthetic(\", \", \"Swift scalar-equality argument separator\", [expression], [path])\n    emitExpression(writer, expression.right, `${path}/right`, declarations)\n    writer.synthetic(\")\", \"Swift scalar-equality helper call\", [expression], [path])\n    return\n  }\n  writer.mapped(\"(\", {mappingKind: \"anchor\", node: expression, path})\n  emitExpression(writer, expression.left, `${path}/left`, declarations)\n  writer.synthetic(\" \", \"operator spacing\", [expression], [path])\n  writer.mapped(binaryOperations[expression.operation], {mappingKind: \"exact\", node: expression, path, role: \"operator\"})\n  writer.synthetic(\" \", \"operator spacing\", [expression], [path])\n  emitExpression(writer, expression.right, `${path}/right`, declarations)\n  writer.mapped(\")\", {mappingKind: \"anchor\", node: expression, path})\n}\n\n/**\n * Converts a validated logical module identity to its Swift namespace suffix.\n * @param {string} id - Logical module identity.\n * @returns {string} Deterministic Swift namespace suffix and filename.\n */\nfunction moduleName(id) {\n  return id.split(/[._-]+/u).map(part => `${part[0].toUpperCase()}${part.slice(1)}`).join(\"\")\n}\n\n/**\n * Clones and normalizes one provenance-bearing semantic module into a one-module project.\n * @param {import(\"../semantic/types.js\").SemanticModule | undefined} candidate - Candidate module.\n * @returns {import(\"../semantic/types.js\").SemanticProgram} Normalized program.\n */\nfunction normalizeSingleModule(candidate) {\n  if (!isPlainObject(candidate)) unsupportedCapability(\"ios\", \"missing or invalid module\", undefined)\n  const module = structuredClone(candidate)\n  const provenanceSources = module.provenance?.sources\n\n  if (!Array.isArray(provenanceSources) || provenanceSources.length != 1 || provenanceSources[0].content === null ||\n    provenanceSources[0].filename != module.location?.filename || typeof provenanceSources[0].language != \"string\") {\n    unsupportedCapability(\"ios\", \"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 = /** @type {import(\"../semantic/types.js\").SemanticProgramModule} */ ({\n    ...module,\n    exports,\n    id: \"main\",\n    imports: [],\n    sourceFilename: provenanceSources[0].filename\n  })\n\n  return {\n    entryModule: \"main\",\n    kind: \"Program\",\n    modules: [programModule],\n    sources: structuredClone(provenanceSources)\n  }\n}\n\n/**\n * Creates a normalized export for a single-module declaration without inventing a source range.\n * @param {{id?: string, location: import(\"../semantic/types.js\").SourceLocation, name: string}} declaration - Exported declaration.\n * @param {import(\"../semantic/types.js\").SemanticDeclarationKind} symbolKind - Declaration namespace.\n * @returns {import(\"../semantic/types.js\").SemanticExport} Synthetic project edge anchored to its declaration.\n */\nfunction applicationExport(declaration, symbolKind) {\n  return {\n    declarationId: /** @type {string} */ (declaration.id),\n    exportedName: declaration.name,\n    kind: \"Export\",\n    location: declaration.location,\n    symbolKind\n  }\n}\n\n/**\n * Prefixes declaration identities and typed references in a cloned single module.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Cloned module.\n * @param {string} moduleId - Normalized 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\n    .filter(declaration => typeof declaration.id == \"string\")\n    .map(declaration => [declaration.id, `${moduleId}#${declaration.id}`]))\n\n  for (const declaration of declarations) {\n    if (typeof declaration.id == \"string\") declaration.id = replacements.get(declaration.id)\n  }\n  const seen = new Set()\n  const identityFields = new Set([\"classId\", \"declarationId\", \"field\", \"method\", \"parameterId\"])\n  /**\n   * Rewrites declaration identities in one cloned semantic subtree.\n   * @param {unknown} value - Candidate semantic subtree.\n   * @returns {void}\n   */\n  function visit(value) {\n    if (!value || typeof value != \"object\" || seen.has(value)) return\n    seen.add(value)\n    if (!Array.isArray(value)) {\n      for (const [key, nested] of Object.entries(value)) {\n        if (identityFields.has(key) && typeof nested == \"string\" && replacements.has(nested)) {\n          Reflect.set(value, key, replacements.get(nested))\n        } else visit(nested)\n      }\n    } else for (const nested of value) visit(nested)\n  }\n  visit(module)\n}\n\n/**\n * Tests for a plain request object.\n * @param {unknown} value - Candidate request.\n * @returns {value is Record<string, unknown>} Whether it is a plain object.\n */\nfunction isPlainObject(value) {\n  return Boolean(value) && typeof value == \"object\" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n"]}