@lucent-lang/lucent 0.1.2 → 0.1.3

package/dist/{src-Bzpv4-ox.js → src-DMbXwPlK.js}

@@ -1,4 +1,4 @@
-import { n as Explanations, r as docsUrl, t as Codes } from "./codes-D-6LxUqD.js";
+import { n as Explanations, r as docsUrl, t as Codes } from "./codes-B6AgFgAq.js";
 import { n as lucentPackages, t as lucentPackageOf } from "./packages-CSmKeaAh.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
@@ -13,19 +13,23 @@ import { spawnSync } from "node:child_process";
 var CompileError = class extends Error {
 	node;
 	code;
-	constructor(node, code, message) {
+	fix;
+	constructor(node, code, message, fix) {
 		super(message);
 		this.node = node;
 		this.code = code;
+		this.fix = fix;
 	}
 };
-function fail$2(node, code, message) {
-	throw new CompileError(node, code, message);
+function fail$2(node, code, message, fix) {
+	throw new CompileError(node, code, message, fix);
 }
 function toDiagnostic(e) {
+	const fix = e.fix ? { fix: e.fix } : {};
 	if (!e.node) return {
 		code: e.code,
-		message: e.message
+		message: e.message,
+		...fix
 	};
 	const sf = e.node.getSourceFile();
 	const start = e.node.getStart(sf);
@@ -37,7 +41,8 @@ function toDiagnostic(e) {
 		line: line + 1,
 		column: character + 1,
 		start,
-		length: e.node.getEnd() - start
+		length: e.node.getEnd() - start,
+		...fix
 	};
 }
 function formatDiagnostic(d) {
@@ -1407,10 +1412,17 @@ const mods$1 = (ms) => [...ms ?? []].sort((a, b) => MODIFIER_ORDER.indexOf(a) -
 const annotations = (as, indent) => (as ?? []).map((a) => `${indent}@${a}`);
 const params$3 = (ps, indent) => ps.map((p) => `${ident(p.name)}: ${printType$2(p.type)}${p.default ? ` = ${expr$2(p.default, PREC$1.lowest, indent)}` : ""}`).join(", ");
 function fun(f, indent) {
-	const tps = f.typeParams?.length ? `<${f.typeParams.map(ident).join(", ")}> ` : "";
+	const bounds = (n) => f.bounds?.[n] ?? [];
+	const typeParam = (n) => {
+		const [only, ...more] = bounds(n);
+		return only && !more.length ? `${ident(n)} : ${printType$2(only)}` : ident(n);
+	};
+	const where = (f.typeParams ?? []).filter((n) => bounds(n).length > 1).flatMap((n) => bounds(n).map((b) => `${ident(n)} : ${printType$2(b)}`));
+	const tps = f.typeParams?.length ? `<${f.typeParams.map(typeParam).join(", ")}> ` : "";
 	const receiver = f.receiver ? `${printType$2(f.receiver)}.` : "";
 	const ret = f.ret ? `: ${printType$2(f.ret)}` : "";
-	const head = `${indent}${mods$1(f.modifiers)}fun ${tps}${receiver}${ident(f.name)}(${params$3(f.params, indent)})${ret}`;
+	const clause = where.length ? ` where ${where.join(", ")}` : "";
+	const head = `${indent}${mods$1(f.modifiers)}fun ${tps}${receiver}${ident(f.name)}(${params$3(f.params, indent)})${ret}${clause}`;
 	return [...annotations(f.annotations, indent), ...f.body ? [
 		`${head} {`,
 		...block$1(f.body, indent + INDENT$2),
@@ -1495,6 +1507,11 @@ const fn$4 = (params, ret) => ({
 	params,
 	ret
 });
+const blockFunction = (params, ret) => ({
+	k: "blockFunction",
+	params,
+	ret
+});
 const opaque = (of) => ({
 	k: "opaque",
 	of
@@ -1526,6 +1543,10 @@ const arrayLiteral = (items) => ({
 	k: "arrayLiteral",
 	items
 });
+const tupleLiteral = (items) => ({
+	k: "tupleLiteral",
+	items
+});
 const dictionaryLiteral = (entries) => ({
 	k: "dictionaryLiteral",
 	entries
@@ -1622,10 +1643,11 @@ const INDENT$1 = "  ";
 function printType$1(t) {
 	switch (t.k) {
 		case "named": return t.args?.length ? `${t.name}<${t.args.map(printType$1).join(", ")}>` : t.name;
-		case "optional": return t.of.k === "cFunction" || t.of.k === "function" ? `(${printType$1(t.of)})?` : `${printType$1(t.of)}?`;
+		case "optional": return t.of.k === "cFunction" || t.of.k === "blockFunction" || t.of.k === "function" ? `(${printType$1(t.of)})?` : `${printType$1(t.of)}?`;
 		case "array": return `[${printType$1(t.of)}]`;
 		case "dictionary": return `[${printType$1(t.key)}: ${printType$1(t.value)}]`;
 		case "cFunction": return `@convention(c) (${t.params.map(printType$1).join(", ")}) -> ${printType$1(t.ret)}`;
+		case "blockFunction": return `@convention(block) (${t.params.map(printType$1).join(", ")}) -> ${printType$1(t.ret)}`;
 		case "function": return `(${t.params.map(printType$1).join(", ")}) -> ${printType$1(t.ret)}`;
 		case "opaque": return `some ${printType$1(t.of)}`;
 	}
@@ -1704,6 +1726,7 @@ function bare(e, indent) {
 		case "self": return "self";
 		case "member": return `${expr$1(e.object, PREC.postfix, indent)}.${e.name}`;
 		case "arrayLiteral": return `[${e.items.map((x) => expr$1(x, PREC.assign, indent)).join(", ")}]`;
+		case "tupleLiteral": return `(${e.items.map((x) => expr$1(x, PREC.assign, indent)).join(", ")})`;
 		case "dictionaryLiteral":
 			if (!e.entries.length) return "[:]";
 			return `[${e.entries.map((x) => `${expr$1(x.key, PREC.assign, indent)}: ${expr$1(x.value, PREC.assign, indent)}`).join(", ")}]`;
@@ -1894,7 +1917,7 @@ function bareType(t) {
 		case "array": return `${t.readonly ? "readonly " : ""}${type$1(t.of, At.arrayElement)}[]`;
 		case "union": return t.members.map((m) => type$1(m, At.unionMember)).join(" | ");
 		case "intersection": return t.members.map((m) => type$1(m, At.intersectionMember)).join(" & ");
-		case "tuple": return `[${t.elements.map((e) => e.optional ? `${type$1(e.type, At.arrayElement)}?` : printType(e.type)).join(", ")}]`;
+		case "tuple": return `[${t.elements.map((e) => e.name ? `${e.name}${e.optional ? "?" : ""}: ${printType(e.type)}` : e.optional ? `${type$1(e.type, At.arrayElement)}?` : printType(e.type)).join(", ")}]`;
 		case "fn": return `(${params$1(t.params)}) => ${printType(t.ret)}`;
 		case "object": return t.members.length ? `{ ${t.members.map((m) => `${m.readonly ? "readonly " : ""}${propertyName$2(m.name)}${m.optional ? "?" : ""}: ${printType(m.type)}`).join("; ")} }` : "{}";
 		case "literal": return typeof t.value === "bigint" ? `${t.value}n` : JSON.stringify(t.value);
@@ -1962,6 +1985,14 @@ function member$2(m) {
 		case "property": {
 			const mods = `${m.private ? "private " : ""}${m.static ? "static " : ""}${m.readonly ? "readonly " : ""}`;
 			const name = m.computed ? `[${m.name}]` : propertyName$2(m.name);
+			if (m.set) {
+				const at = `${INDENT}${m.private ? "private " : ""}${m.static ? "static " : ""}`;
+				return [
+					...doc,
+					`${at}get ${name}(): ${printType(m.type)};`,
+					`${at}set ${name}(value: ${printType(m.set)});`
+				];
+			}
 			return [...doc, `${INDENT}${mods}${name}${m.optional ? "?" : ""}: ${printType(m.type)};`];
 		}
 		case "call": return [...doc, `${INDENT}${typeParams(m.typeParams)}(${params$1(m.params)}): ${printType(m.ret)};`];
@@ -2146,7 +2177,7 @@ const stmt = (s) => ({
 const blank = { k: "blank" };
 //#endregion
 //#region ../codegen/src/xml/index.ts
-const element$1 = (name, attributes = {}, children) => children ? {
+const element$2 = (name, attributes = {}, children) => children ? {
 	name,
 	attributes,
 	children
@@ -2365,7 +2396,7 @@ const PRIMS$1 = [
 	"uint64"
 ];
 function parseSchemaType(s, module = "", typeParams = []) {
-	const toks = s.match(/@\w+|=>|[()[\]<>?,]|[\w.$]+/g) ?? [];
+	const toks = s.match(/@\w+|=>|[()[\]<>?,:]|[\w.$]+/g) ?? [];
 	let p = 0;
 	const expect = (t) => {
 		if (toks[p++] !== t) throw new Error(`schema type ${s}: expected ${t}`);
@@ -2430,6 +2461,26 @@ function parseSchemaType(s, module = "", typeParams = []) {
 					nullable: false
 				};
 			}
+			if (name === "Tuple") {
+				const of = [];
+				const labels = [];
+				for (;;) {
+					if (toks[p + 1] === ":") {
+						labels.push(toks[p]);
+						p += 2;
+					}
+					of.push(type());
+					if (toks[p] !== ",") break;
+					p++;
+				}
+				expect(">");
+				return {
+					k: "tuple",
+					of,
+					...labels.length === of.length ? { labels } : {},
+					nullable: false
+				};
+			}
 			const args = [type()];
 			while (toks[p] === ",") {
 				p++;
@@ -2578,6 +2629,7 @@ function formatSchemaType(t) {
 		}
 		case "record": return t.cf ? `CFDictionary${q}` : `Record<${formatSchemaType(t.of)}>${q}`;
 		case "set": return `Set<${formatSchemaType(t.of)}>${q}`;
+		case "tuple": return `Tuple<${t.of.map((x, i) => `${t.labels ? `${t.labels[i]}: ` : ""}${formatSchemaType(x)}`).join(", ")}>${q}`;
 		case "out": return `Out<${formatSchemaType(t.of)}>${q}`;
 		case "classOf": return `Class<${t.param}>${q}`;
 		case "tparam": return `${t.name}${q}`;
@@ -3864,13 +3916,15 @@ const CLASS_KINDS = {
 };
 function classView(k, internal, c) {
 	const bounds = boundsOf(c.typeParameters);
+	const upperBounds = upperBoundsOf(c.typeParameters, []);
 	const view = membersView({
 		kind: CLASS_KINDS[c.kind],
 		...c.data ? { data: true } : {},
 		...c.fun ? { fun: true } : {},
 		...c.modality === "sealed" ? { sealed: c.sealedSubclasses } : {},
 		...c.valueClass ? { value: c.valueClass } : {},
-		...bounds ? { bounds } : {}
+		...bounds ? { bounds } : {},
+		...upperBounds ? { upperBounds } : {}
 	}, [c]);
 	for (const ctor of c.constructors) {
 		if (ctor.jvm) view.members.set(ctor.jvm.name + ctor.jvm.descriptor, {
@@ -3902,7 +3956,8 @@ function membersView(facts, owners) {
 			if (!f.jvm) continue;
 			view.members.set(f.jvm.name + f.jvm.descriptor, {
 				role: "function",
-				function: f
+				function: f,
+				outer: owner.typeParameters ?? []
 			});
 			if (f.parameters.some((p) => p.declaresDefault)) view.overloaded.add(f.jvm.name);
 		}
@@ -3931,6 +3986,38 @@ function boundsOf(params) {
 	}
 	return Object.keys(bounds).length ? bounds : void 0;
 }
+function upperBoundsOf(params, outer) {
+	const names = new Map([...outer, ...params].map((p) => [p.id, p.name]));
+	const bounds = boundsOf(params) ?? {};
+	const upper = {};
+	for (const p of params) {
+		if (bounds[p.name] !== "other") continue;
+		const refs = p.upperBounds.map((b) => typeRef(b, names));
+		if (refs.every((r) => r !== void 0)) upper[p.name] = refs;
+	}
+	return Object.keys(upper).length ? upper : void 0;
+}
+function typeRef(t, names) {
+	const c = t.classifier;
+	const name = "class" in c ? c.class.replaceAll("/", ".") : "typeAlias" in c ? c.typeAlias.replaceAll("/", ".") : names.get(c.typeParameter);
+	if (!name) return void 0;
+	const args = [];
+	for (const a of t.arguments) {
+		if (a === "*") {
+			args.push("*");
+			continue;
+		}
+		if (a.variance !== "invariant") return void 0;
+		const ref = typeRef(a.type, names);
+		if (!ref) return void 0;
+		args.push(ref);
+	}
+	return {
+		name,
+		...args.length ? { args } : {},
+		...t.nullable ? { nullable: true } : {}
+	};
+}
 function kotlinSignature(member) {
 	switch (member.role) {
 		case "function": {
@@ -3940,6 +4027,7 @@ function kotlinSignature(member) {
 				type: f.receiver
 			}] : [];
 			const bounds = boundsOf(f.typeParameters);
+			const upperBounds = upperBoundsOf(f.typeParameters, member.outer);
 			return {
 				name: f.name,
 				params: [
@@ -3955,7 +4043,8 @@ function kotlinSignature(member) {
 				facts: {
 					...f.suspend ? { suspend: true } : {},
 					...f.receiver ? { extension: true } : {},
-					...bounds ? { bounds } : {}
+					...bounds ? { bounds } : {},
+					...upperBounds ? { upperBounds } : {}
 				}
 			};
 		}
@@ -4010,7 +4099,7 @@ function jvmSymbol(internal, member) {
 let extractorHash;
 function extractorVersion() {
 	if (extractorHash) return extractorHash;
-	return extractorHash = "9bb0f2e9";
+	return extractorHash = "ed6f33c6";
 }
 const contentHashes = /* @__PURE__ */ new Map();
 function contentHash(files) {
@@ -4057,7 +4146,7 @@ function jarArtifact(file) {
 }
 function iosProvenance(module, source, sdkVersion, target) {
 	return {
-		artifact: source.pod ? `pod:${source.pod}` : source.kind === "sdk" ? `sdk:iphonesimulator${sdkVersion}` : `${source.kind}:${module}`,
+		artifact: source.pod ? `pod:${source.pod}` : source.spm ? `spm:${source.spm}` : source.kind === "sdk" ? `sdk:iphonesimulator${sdkVersion}` : `${source.kind}:${module}`,
 		kind: source.kind,
 		...source.files.length ? { contentHash: contentHash(source.files) } : {},
 		target,
@@ -4459,11 +4548,27 @@ function extractAndroid(opts) {
 						});
 						throw new Unsupported$1("java.lang.Class");
 					}
-					if (!known.has(t.name)) throw new Unsupported$1(t.name.replace(/\//g, "."));
 					const typeArg = (a, i) => {
 						const at = argument(i, t.args.length);
 						return boxedAs(at, a) ?? typeOf(a, true, tparams, at);
 					};
+					if (kotlinFunction$1(t, kt)) {
+						const last = t.args.length - 1;
+						const result = argument(last, t.args.length);
+						try {
+							return nullable({
+								k: "fn",
+								params: t.args.slice(0, last).map(typeArg),
+								ret: classOfKotlin(result) === "kotlin/Unit" ? parseSchemaType("void") : typeArg(t.args[last], last),
+								escaping: true,
+								main: false,
+								nullable: false
+							});
+						} catch (e) {
+							if (!(e instanceof Unsupported$1)) throw e;
+						}
+					}
+					if (!known.has(t.name)) throw new Unsupported$1(t.name.replace(/\//g, "."));
 					if (readOnlyList(t, kt)) try {
 						return nullable({
 							k: "array",
@@ -4693,6 +4798,9 @@ function extractAndroid(opts) {
 			if (ks?.name && ks.name !== m.name) {
 				method.name = ks.name;
 				method.java = m.name;
+			} else if (member && mangled(m.name)) {
+				method.name = m.name.slice(0, m.name.indexOf("-"));
+				method.java = m.name;
 			}
 			if (Object.keys(kotlinFacts).length) method.kotlin = kotlinFacts;
 			if (m.access & ACC.STATIC) method.static = true;
@@ -4815,6 +4923,9 @@ function boxedAs(kt, t) {
 function readOnlyList(t, kt) {
 	return t.name === "java/util/List" && t.args.length === 1 && !!kt && !kt.platform && classOfKotlin(kt) === "kotlin/collections/List" && typeArgument(kt, 0) !== void 0;
 }
+function kotlinFunction$1(t, kt) {
+	return /^kotlin\/jvm\/functions\/Function\d+$/.test(t.name) && !!kt && !kt.platform && !kt.suspend && !kt.annotations?.length && classOfKotlin(kt) === `kotlin/${t.name.slice(t.name.lastIndexOf("/") + 1)}` && kt.arguments.length === t.args.length && kt.arguments.every((a) => a !== "*");
+}
 function typeArgument(kt, i) {
 	const a = kt?.arguments[i];
 	return a && a !== "*" ? a.type : void 0;
@@ -5276,18 +5387,32 @@ function parseType(frags, r) {
 		}
 		if (tok === "(") {
 			const items = [];
+			const labels = [];
 			while (toks[p] !== ")") {
+				const label = toks[p];
+				if (typeof label === "string" && /^\w+$/.test(label) && toks[p + 1] === ":") {
+					labels.push(label);
+					p += 2;
+				}
 				items.push(type());
 				if (toks[p] === ",") p++;
 				else break;
 			}
 			if (toks[p++] !== ")") throw new Unsupported("closures and tuples");
 			if (toks[p] === "->") {
+				if (labels.length) throw new Unsupported("closures with labeled parameters");
 				p++;
 				return closure(items, attrs);
 			}
-			if (items.length === 1 && !attrs.length) return items[0];
-			throw new Unsupported("tuples");
+			if (items.length === 1 && !attrs.length && !labels.length) return items[0];
+			if (!items.length && !attrs.length) return parseSchemaType("void");
+			if (attrs.length) throw new Unsupported(`type syntax ${attrs.join(" ")}`);
+			return {
+				k: "tuple",
+				of: items,
+				...labels.length === items.length ? { labels } : {},
+				nullable: false
+			};
 		}
 		if (tok === "->") throw new Unsupported("closures and tuples");
 		if (attrs.length) throw new Unsupported(`type syntax ${attrs.join(" ")}`);
@@ -5621,6 +5746,7 @@ function undeclaredType(t, declared) {
 		case "record":
 		case "out": return undeclaredType(t.of, declared);
 		case "fn": return [...t.params, t.ret].map((x) => undeclaredType(x, declared)).find(Boolean);
+		case "tuple": return t.of.map((x) => undeclaredType(x, declared)).find(Boolean);
 		default: return;
 	}
 }
@@ -5666,8 +5792,8 @@ const NOT_JAVA = /* @__PURE__ */ new Set([
 	"id",
 	"record",
 	"set",
+	"tuple",
 	"out",
-	"fn",
 	"error"
 ]);
 const SWIFT_SCALARS = {
@@ -5932,26 +6058,19 @@ function needsKotlinShim(member) {
 	return !!k?.suspend || !!k?.unboxed || "params" in member && member.params.some((p) => p.kotlin?.suspendFunction);
 }
 function bounded$1(owner, member) {
-	const other = (bounds) => !!bounds && Object.values(bounds).includes("other");
-	return other(owner?.kotlin?.bounds) || other(member.kotlin?.bounds);
+	const unwritable = (facts) => Object.entries(facts?.bounds ?? {}).some(([name, bound]) => bound === "other" && !facts?.upperBounds?.[name]);
+	return unwritable(owner?.kotlin) || unwritable(member.kotlin);
 }
 function omitsKotlinDefault(owner, member, param) {
 	return !!param.kotlin?.default && !bounded$1(owner, member);
 }
-const KOTLIN_SHIM_REFUSALS = [
-	[(owner, member) => bounded$1(owner, member), {
-		rule: "kotlin-shim-generic",
-		reason: "generic Kotlin members whose type parameters have bounds are not supported through a shim yet"
-	}],
-	[(_, __, role) => role === "set", {
-		rule: "kotlin-shim",
-		reason: "assigning Kotlin value classes is not supported yet"
-	}],
-	[(_, __, role) => role === "implement", {
-		rule: "kotlin-shim",
-		reason: "Lucent classes cannot implement suspend functions or value-class members yet"
-	}]
-];
+const KOTLIN_SHIM_REFUSALS = [[(owner, member) => bounded$1(owner, member), {
+	rule: "kotlin-shim-generic",
+	reason: "generic Kotlin members bounded by a projected type (`T : List<out R>`) are not supported through a shim yet"
+}], [(owner, _, role) => role === "implement" && !owner?.interface, {
+	rule: "kotlin-shim",
+	reason: "Lucent classes cannot override a Kotlin class's suspend or value-class members yet"
+}]];
 const UI_APPLIER$1 = "androidx.compose.ui.UiComposable";
 const simpleName = (kotlinName) => kotlinName.slice(kotlinName.lastIndexOf("/") + 1);
 const KOTLIN_SOURCE_REFUSALS = [
@@ -6011,9 +6130,9 @@ function refusalOf(owner, member, backend, role) {
 		};
 	}
 	const jvmName = "java" in member ? member.java : void 0;
-	if (backend === "jni" && role === "implement" && jvmName && !javaIdentifier(jvmName)) return {
+	if (backend === "jni" && role === "implement" && !owner?.interface && jvmName && !javaIdentifier(jvmName)) return {
 		rule: "jvm-mangled-name",
-		reason: `a method whose JVM name Java cannot write (${jvmName}) cannot be implemented`
+		reason: `a method whose JVM name Java cannot write (${jvmName}) cannot be overridden`
 	};
 	if (backend !== "swift-shim") return void 0;
 	if (role === "new" && member.swift?.async) return {
@@ -6051,9 +6170,12 @@ function requirementDelivery(backend, owner, m) {
 	return !isVoid || owner?.mainActor || m.mainActor ? "sync" : "queued";
 }
 function resultOwnership(owner, member, module, role, facts) {
-	if (module.platform !== "ios" || member.swift || role !== "call" || !("returns" in member)) return facts;
+	const cFunction = "cFunction" in member ? member.cFunction?.name : void 0;
+	const made = role === "new" && !!cFunction;
+	if (module.platform !== "ios" || member.swift) return facts;
+	if (!made && (role !== "call" || !("returns" in member))) return facts;
 	if (facts.ownership !== "unknown") return facts;
-	const rule = owner ? /^(alloc|new|copy|mutableCopy|create)(?![a-z])/.test(member.selector ?? member.name) ? "objc-method-family" : void 0 : /Create|Copy/.test(member.name) ? "cf-create-rule" : void 0;
+	const rule = cFunction ? /Create|Copy/.test(cFunction) ? "cf-create-rule" : void 0 : owner ? /^(alloc|new|copy|mutableCopy|create)(?![a-z])/.test(member.selector ?? ("name" in member ? member.name : "")) ? "objc-method-family" : void 0 : /Create|Copy/.test("name" in member ? member.name : "") ? "cf-create-rule" : void 0;
 	if (!rule) return facts;
 	const evidence = {
 		fact: "ownership",
@@ -6141,6 +6263,11 @@ function kindConversion(t, place, ctx) {
 			type: t,
 			of: [inner(t.of, { element: true })]
 		};
+		case "tuple": return {
+			op: "copy-tuple",
+			type: t,
+			of: t.of.map((x) => inner(x, { element: true }))
+		};
 		case "record": return withDetail({
 			op: "copy-record",
 			type: t,
@@ -6255,9 +6382,15 @@ function kotlinSourceRule(t, place) {
 }
 function jniRule(t, place, ctx) {
 	if (t.k === "array" && !t.list && t.of.k === "tparam" && place.flow === "in") return "arrays of a type parameter's values cannot be passed to Java yet";
+	if (ctx.backend === "jni" && t.k === "fn" && [...t.params, t.ret].some((x) => x.k === "fn")) return "Kotlin functions taking or giving functions are not supported yet";
 	if (ctx.role !== "implement") return void 0;
 	if (place.offered && t.k === "prim" && t.name === "char") return "a char argument is not supported yet";
-	if (place.result && t.k !== "prim" && t.k !== "string" && t.k !== "tparam") return `Lucent functions cannot return a ${formatSchemaType({
+	if (place.result && ![
+		"prim",
+		"string",
+		"tparam",
+		"ref"
+	].includes(t.k)) return `Lucent functions cannot return a ${formatSchemaType({
 		...t,
 		nullable: false
 	})} to Java yet`;
@@ -6299,6 +6432,21 @@ function swiftRule(t, place, ctx) {
 		case "date":
 		case "id":
 		case "tparam": return;
+		case "fn": {
+			const blockable = (x, result) => {
+				if (x.k === "prim") return result && x.name === "void" || !!SWIFT_SCALARS[x.name] && !x.nullable;
+				if (x.k === "string") return true;
+				if (x.k !== "ref") return false;
+				const facts = ctx.types(x.module, x.name);
+				return (facts?.kind === "class" || facts?.kind === "protocol") && !facts.swift;
+			};
+			if (![...t.params.map((x) => blockable(x, false)), blockable(t.ret, true)].every(Boolean)) return not("closures taking or giving values other than numbers, booleans, strings and Objective-C objects");
+			return t.nullable ? not("optional closures") : void 0;
+		}
+		case "tuple":
+			if (t.of.some((x) => x.nullable)) return not("tuples of optional values");
+			if (t.of.some((x) => isStruct(x, ctx))) return not("tuples of C structs");
+			return t.nullable ? not("optional tuples") : void 0;
 		case "array":
 		case "record":
 			if (t.of.nullable) return not("collections of optional values");
@@ -6351,6 +6499,51 @@ function hasUnion$1(t, ctx) {
 	return swift !== void 0 && swift !== true && !!swift.cases;
 }
 //#endregion
+//#region ../bindgen/src/c-swift-names.ts
+function cSwiftNames(dirs) {
+	const out = /* @__PURE__ */ new Map();
+	for (const dir of dirs) {
+		const files = fs.existsSync(dir) ? fs.readdirSync(dir) : [];
+		for (const f of files.filter((x) => x.endsWith(".h"))) for (const [name, swift] of attributeNames(fs.readFileSync(path.join(dir, f), "utf8"))) out.set(name, swift);
+		for (const f of files.filter((x) => x.endsWith(".apinotes"))) for (const [name, swift] of apiNoteNames(fs.readFileSync(path.join(dir, f), "utf8"))) out.set(name, swift);
+	}
+	return out;
+}
+function apiNoteNames(text) {
+	const out = [];
+	const items = text.split(/^\s*- (?=Name:)/m).slice(1);
+	for (const item of items) {
+		const name = /^Name:\s*(\w+)/.exec(item)?.[1];
+		const own = item.split(/\n(?=\S|\s*- )/)[0];
+		const swift = /^\s*SwiftName:\s*'?([^'\n]+?)'?\s*$/m.exec(own)?.[1];
+		if (name && swift) out.push([name, swift]);
+	}
+	return out;
+}
+function attributeNames(text) {
+	const out = [];
+	for (const m of text.matchAll(/\b(?:CF|NS|CG)_SWIFT_NAME\(([^()]*\([^()]*\))\)|swift_name\("([^"]+)"\)/g)) {
+		const swift = m[1] ?? m[2];
+		const before = text.slice(0, m.index);
+		const start = Math.max(before.lastIndexOf(";"), before.lastIndexOf("}")) + 1;
+		const name = /\b(\w+)\s*\(/.exec(before.slice(start))?.[1];
+		if (name) out.push([name, swift]);
+	}
+	return out;
+}
+function swiftMemberOf(swift) {
+	const m = /^(?:(getter|setter):)?([\w.]+)\.(\w+)\(([^)]*)\)$/.exec(swift);
+	if (!m) return void 0;
+	const [, accessor, type, name, args] = m;
+	const self = args.split(":").filter((l) => l !== "").indexOf("self");
+	return {
+		kind: accessor === "getter" || accessor === "setter" ? accessor : name === "init" ? "init" : "method",
+		type,
+		name,
+		...self >= 0 ? { self } : {}
+	};
+}
+//#endregion
 //#region ../bindgen/src/swift.ts
 const TYPE_KINDS$1 = {
 	"swift.struct": "struct",
@@ -6562,7 +6755,9 @@ function addSwiftDeclarations(ctx) {
 				bytes: true
 			}
 		});
-		if (bound.ctors.length) cls.constructors = bound.ctors;
+		const apart = factoriesOfSameTyped(bound.ctors, `${module}.${cls.name}`);
+		bound.methods.push(...apart.factories);
+		if (apart.ctors.length) cls.constructors = apart.ctors;
 		if (bound.methods.length) cls.methods = bound.methods;
 		if (bound.props.length) cls.properties = bound.props;
 		mod.types.push(cls);
@@ -6580,7 +6775,11 @@ function addSwiftDeclarations(ctx) {
 		const methods = withoutPropertyNames(bound.methods, cls.properties ?? [], bound.symbols, skip);
 		for (const m of methods) if (!has(cls.methods, m.name)) (cls.methods ??= []).push(m);
 		for (const p of bound.props) if (!has(cls.properties, p.name)) (cls.properties ??= []).push(p);
-		if (bound.ctors.length && !cls.constructors?.length) cls.constructors = bound.ctors;
+		if (bound.ctors.length && !cls.constructors?.length) {
+			const apart = factoriesOfSameTyped(bound.ctors, `${module}.${cls.name}`);
+			for (const f of apart.factories) if (!has(cls.methods, f.name)) (cls.methods ??= []).push(f);
+			if (apart.ctors.length) cls.constructors = apart.ctors;
+		}
 	}
 	for (const s of g.symbols) {
 		const usr = s.identifier.precise;
@@ -6862,6 +7061,44 @@ function payload(c, r) {
 		} : { type };
 	});
 }
+function factoriesOfSameTyped(ctors, self) {
+	const key = (c) => c.params.map((p) => typeKind(formatSchemaType({
+		...p.type,
+		nullable: false
+	}))).join(",");
+	const groups = /* @__PURE__ */ new Map();
+	for (const c of ctors) groups.set(key(c), [...groups.get(key(c)) ?? [], c]);
+	const capitalized = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+	const byLabels = (c) => `with${splitName(c.swift?.name ?? "init()").labels.filter((l) => l !== "_").map(capitalized).join("")}`;
+	const unlabeled = (c) => splitName(c.swift?.name ?? "init()").labels.every((l) => l === "_");
+	const byTypes = (c) => `with${c.params.map((p) => capitalized(formatSchemaType(p.type).replace(/\W/g, ""))).join("")}`;
+	const factories = [];
+	const turned = /* @__PURE__ */ new Set();
+	for (const all of groups.values()) {
+		if (all.length < 2) continue;
+		const bare = all.filter((c) => !c.params.length || unlabeled(c));
+		const group = bare.length === 1 ? all.filter((c) => c !== bare[0]) : all;
+		const labelled = group.map(byLabels);
+		const names = new Set(labelled).size === group.length ? labelled : group.map(byTypes);
+		if (new Set(names).size !== group.length) continue;
+		group.forEach((c, i) => {
+			factories.push({
+				...c,
+				name: names[i],
+				static: true,
+				returns: parseSchemaType(self)
+			});
+			turned.add(c);
+		});
+	}
+	return {
+		ctors: ctors.filter((c) => !turned.has(c)),
+		factories
+	};
+}
+function typeKind(t) {
+	return /^(double|float|CGFloat|NSInteger|NSUInteger|u?int(8|16|32|64)?|short|byte)$/.test(t) ? "number" : t;
+}
 //#endregion
 //#region ../bindgen/src/ios.ts
 const DEFAULT_TARGET = "arm64-apple-ios15.1-simulator";
@@ -7142,6 +7379,26 @@ function externalUsrs(g) {
 	for (const r of g.relationships) if (r.target.startsWith("c:") && !declared.has(r.target)) out.add(r.target);
 	return out;
 }
+function withInheritedInitializers(mod) {
+	const classes = new Map(mod.types.filter((t) => t.kind === "class").map((c) => [c.name, c]));
+	for (const cls of classes.values()) {
+		if (!cls.inheritsInit || !cls.constructors?.length) continue;
+		let inherited;
+		for (let at = cls.extends, depth = 0; at && depth < 64 && !inherited; depth++) {
+			const [owner, ...rest] = at.split(".");
+			const sup = owner === mod.module ? classes.get(rest.join(".")) : void 0;
+			if (!sup) break;
+			const own = (sup.constructors ?? []).filter((c) => !c.factory);
+			if (own.length) inherited = own;
+			else if (!sup.inheritsInit) break;
+			at = sup.extends;
+		}
+		if (inherited) {
+			cls.constructors.push(...inherited.map((c) => ({ ...c })));
+			delete cls.inheritsInit;
+		}
+	}
+}
 function keepInheritedNonNull(mod, unaudited) {
 	const classes = new Map(mod.types.filter((t) => t.kind === "class").map((c) => [c.name, c]));
 	const inheritedNonNull = (cls, p) => {
@@ -7293,7 +7550,7 @@ function inheritedConformances(classUsr, lineage) {
 	}
 	return out;
 }
-function buildIosSchema(module, g, names, values) {
+function buildIosSchema(module, g, names, values, importedNames = /* @__PURE__ */ new Map()) {
 	const refs = new Map(names.flatMap((n) => Object.entries(n.refs)));
 	const aliases = new Map(names.flatMap((n) => Object.entries(n.aliases)));
 	const unaudited = /* @__PURE__ */ new Set();
@@ -7401,15 +7658,90 @@ function buildIosSchema(module, g, names, values) {
 				properties: props
 			});
 		}
+		const cfMembers = (cls, list, setters) => {
+			const r = resolver();
+			for (const mem of list) {
+				const fn = /^c:@F@(\w+)$/.exec(mem.identifier.precise)?.[1];
+				if (!fn || unavailable(mem)) continue;
+				const imported = importedNames.get(fn);
+				const member = imported ? swiftMemberOf(imported) : void 0;
+				const symbol = graphSymbol(mem.identifier.precise);
+				const v = since(mem);
+				try {
+					if (!member) throw new Unsupported(`${fn}'s Swift name is in no API notes or header Lucent reads`);
+					const k = mem.kind.identifier;
+					if (k === "swift.property" || k === "swift.type.property") {
+						if (member.kind !== "getter") continue;
+						const setter = setters.get(`${member.type}.${member.name}`);
+						const p = {
+							name: mem.names.title,
+							type: parseType(propertyType(mem.declarationFragments ?? []), r),
+							cFunctions: {
+								getter: fn,
+								...setter ? { setter } : {}
+							},
+							symbol
+						};
+						if (!setter) p.readonly = true;
+						if (member.self === void 0) p.static = true;
+						if (v && v !== cls.since) p.since = v;
+						(cls.properties ??= []).push(p);
+						continue;
+					}
+					const sig = mem.functionSignature;
+					const params = (sig?.parameters ?? []).map((pp) => ({
+						name: pp.internalName ?? pp.name,
+						type: parseType(afterColon(pp.declarationFragments), r)
+					}));
+					if (k === "swift.init") {
+						if (/\binit\?/.test(declText(mem))) throw new Unsupported("a failable initializer");
+						const c = {
+							params,
+							cFunction: { name: fn },
+							symbol
+						};
+						if (v && v !== cls.since) c.since = v;
+						(cls.constructors ??= []).push(c);
+						continue;
+					}
+					if (k !== "swift.method" && k !== "swift.type.method") continue;
+					const m = {
+						name: splitName(mem.names.title).base,
+						params,
+						returns: sig?.returns?.length ? parseType(sig.returns, r) : parseSchemaType("void"),
+						cFunction: {
+							name: fn,
+							...member.self !== void 0 ? { self: member.self } : {}
+						},
+						symbol
+					};
+					if (member.self === void 0) m.static = true;
+					if (v && v !== cls.since) m.since = v;
+					(cls.methods ??= []).push(m);
+				} catch (e) {
+					if (e instanceof Unsupported) skip(cls.name, mem, e.message);
+					else throw e;
+				}
+			}
+			if (cls.methods) disambiguate(cls.methods);
+		};
+		const setters = /* @__PURE__ */ new Map();
+		for (const [fn, imported] of importedNames) {
+			const member = swiftMemberOf(imported);
+			if (member?.kind === "setter") setters.set(`${member.type}.${member.name}`, fn);
+		}
 		for (const s of g.symbols) {
 			const handle = s.kind.identifier === "swift.class" ? typedefName(s.identifier.precise) : void 0;
-			if (handle && !unavailable(s)) mod.types.push({
+			if (!handle || unavailable(s)) continue;
+			const cls = {
 				kind: "class",
 				name: s.pathComponents.join("_"),
 				native: handle,
 				cf: true,
 				symbol: graphSymbol(s.identifier.precise)
-			});
+			};
+			cfMembers(cls, members.get(s.identifier.precise) ?? [], setters);
+			mod.types.push(cls);
 		}
 		const objcClasses = /* @__PURE__ */ new Map();
 		for (const s of g.symbols) {
@@ -7492,10 +7824,10 @@ function buildIosSchema(module, g, names, values) {
 						type: withEscaping(parseType(afterColon(pp.declarationFragments), r), escaping[i])
 					}));
 					if (mem.kind.identifier === "swift.init") {
-						if (kind === "cm") continue;
 						const c = {
 							params,
 							selector,
+							...kind === "cm" ? { factory: true } : {},
 							symbol
 						};
 						if (facts) c.facts = facts;
@@ -7520,7 +7852,9 @@ function buildIosSchema(module, g, names, values) {
 					const twin = asyncTwins.get(mem.identifier.precise);
 					if (twin) try {
 						const tr = twin.functionSignature?.returns;
-						method.async = { returns: tr?.length ? parseType(tr, r) : parseSchemaType("void") };
+						const settled = tr?.length ? parseType(tr, r) : parseSchemaType("void");
+						if (settled.k === "tuple") throw new Unsupported("tuples");
+						method.async = { returns: settled };
 						if (/\bthrows\b/.test(declText(twin))) method.async.throws = true;
 						const asyncName = splitName(twin.names.title).base;
 						if (asyncName !== base) method.async.name = asyncName;
@@ -7551,7 +7885,7 @@ function buildIosSchema(module, g, names, values) {
 				if (swiftName) swiftNames.set(x, swiftName);
 				delete x.swiftName;
 			}
-			if (!ctors.length && !initUnavailable && k === "swift.class") {
+			if (!ctors.some((c) => !c.factory) && !initUnavailable && k === "swift.class") {
 				if (cls.extends) cls.inheritsInit = true;
 				else ctors.push({
 					params: [],
@@ -7621,6 +7955,7 @@ function buildIosSchema(module, g, names, values) {
 			return !!t && (t.typeParams ?? 0) === arity;
 		});
 		keepInheritedNonNull(mod, unaudited);
+		withInheritedInitializers(mod);
 		resolveMemberKinds(mod, names);
 		return mod;
 	}
@@ -7863,7 +8198,7 @@ function iosArtifacts(memo, inputs) {
 	}];
 	const groups = /* @__PURE__ */ new Map();
 	for (const [module, source] of sources) {
-		const id = source.pod ? `pod:${source.pod}` : `${source.kind}:${module}`;
+		const id = source.pod ? `pod:${source.pod}` : source.spm ? `spm:${source.spm}` : `${source.kind}:${module}`;
 		const group = groups.get(id) ?? {
 			source,
 			modules: []
@@ -7887,6 +8222,10 @@ function iosArtifacts(memo, inputs) {
 				package: name,
 				version: pod.version,
 				buildFile: inputs.lockfile
+			} : source.spm ? {
+				package: source.spm.slice(0, source.spm.lastIndexOf("@")),
+				version: source.spm.slice(source.spm.lastIndexOf("@") + 1),
+				buildFile: inputs.resolved ?? files[0] ?? ""
 			} : {
 				package: modules[0],
 				version: "",
@@ -8413,12 +8752,10 @@ function extractionCount() {
 	return extractions;
 }
 const loaded$1 = /* @__PURE__ */ new Map();
-const located$3 = /* @__PURE__ */ new Map();
 const iosSdks = /* @__PURE__ */ new Map();
 const headerIndexes = /* @__PURE__ */ new Map();
 function forgetLoadedSdks() {
 	loaded$1.clear();
-	located$3.clear();
 	iosSdks.clear();
 	headerIndexes.clear();
 	locatedByObject = /* @__PURE__ */ new WeakMap();
@@ -8601,7 +8938,11 @@ function locateIos(opts) {
 	const includePaths = opts.ios?.includePaths ?? [];
 	const root = cacheRoot(opts.cacheDir);
 	const memo = memoDir(root);
-	const frameworkPaths = [...opts.ios?.frameworkPaths ?? [], ...(opts.ios?.frameworks ?? []).map((f) => podFramework(memo, f))];
+	const frameworkPaths = [
+		...opts.ios?.frameworkPaths ?? [],
+		...(opts.ios?.frameworks ?? []).map((f) => podFramework(memo, f)),
+		...new Set((opts.ios?.swiftPackages?.modules ?? []).filter((m) => m.framework).map((m) => m.dir))
+	];
 	const moduleMaps = opts.ios?.moduleMaps ?? [];
 	const defines = opts.ios?.defines ?? [];
 	const frameworks = path.join(sdk, "System/Library/Frameworks");
@@ -8638,6 +8979,17 @@ function locateIos(opts) {
 		}
 	}
 	for (const map of moduleMaps) readMap(map);
+	const packages = opts.ios?.swiftPackages;
+	for (const m of packages?.modules ?? []) {
+		if (m.framework) continue;
+		modules.set(m.module, []);
+		sources.set(m.module, {
+			kind: "swift-module",
+			files: [path.join(m.dir, `${m.module}.swiftmodule`)],
+			spm: m.package
+		});
+	}
+	const packageDirs = [...new Set((packages?.modules ?? []).filter((m) => !m.framework).map((m) => m.dir))];
 	for (const dir of frameworkPaths) for (const f of fs.existsSync(dir) ? fs.readdirSync(dir) : []) {
 		if (!f.endsWith(".framework")) continue;
 		const name = f.slice(0, -10);
@@ -8649,6 +9001,10 @@ function locateIos(opts) {
 		});
 		frameworkDirs.set(name, dir);
 	}
+	for (const m of packages?.modules ?? []) {
+		const source = m.framework ? sources.get(m.module) : void 0;
+		if (source) source.spm = m.package;
+	}
 	for (const f of opts.ios?.frameworks ?? []) sources.set(f.module, {
 		kind: "framework",
 		files: [
@@ -8666,13 +9022,15 @@ function locateIos(opts) {
 			if (pod) source.pod = `${pod}@${pods.get(pod).version}`;
 		}
 	}
+	const deployment = opts.ios?.deploymentTarget;
 	const ios = {
 		modules: [],
-		includePaths,
+		includePaths: [...includePaths, ...packageDirs],
 		frameworkPaths,
 		moduleMaps,
 		defines,
-		xcrun
+		xcrun,
+		...deployment ? { target: `arm64-apple-ios${deployment}-simulator` } : {}
 	};
 	const targetTriple = iosTarget(ios);
 	const artifacts = iosArtifacts(memo, {
@@ -8685,7 +9043,8 @@ function locateIos(opts) {
 		sources,
 		lockfile,
 		pods,
-		includePaths,
+		...packages?.resolved ? { resolved: packages.resolved } : {},
+		includePaths: ios.includePaths ?? [],
 		compilerArguments: defines.map((d) => `-D${d}`),
 		targetTriple
 	});
@@ -8707,7 +9066,8 @@ function locateIos(opts) {
 			modules,
 			umbrellas,
 			frameworkDirs,
-			sources
+			sources,
+			packageFailures: packages?.failures ?? []
 		}
 	}, (a) => a.modules.filter((m) => byModule.get(m) === a));
 }
@@ -8821,7 +9181,9 @@ function iosNotFound(r, module) {
 		ios.frameworkPaths?.length ? `${ios.frameworkPaths.length} framework path${ios.frameworkPaths.length === 1 ? "" : "s"}` : ""
 	].filter(Boolean);
 	const pods = extra.length ? ` and the app's pods (${extra.join(", ")}); run pod install after adding a pod` : "; no pods were read: when it comes from a pod, run pod install first";
-	return { missing: `lucent:ios/${module} was not found in the SDK or the app's dependencies (${`looked in ${r.ios.frameworks}${pods}`})` };
+	const where = `looked in ${r.ios.frameworks}${pods}`;
+	const failed = r.ios.packageFailures;
+	return { missing: `lucent:ios/${module} was not found in the SDK or the app's dependencies (${where})${failed.length ? `; the app's Swift packages could not all be built: ${failed.join("; ")}` : ""}` };
 }
 function extractIosModule(r, module) {
 	const { modules, sdk: sdkPath, ios } = r.ios;
@@ -8838,7 +9200,7 @@ function extractIosModule(r, module) {
 	referenced.delete(module);
 	const names = [own, ...namesFor(r, [...referenced].filter((m) => modules.has(m)))];
 	const headers = modules.get(module) ?? [`${module}/${module}.h`];
-	const schema = buildIosSchema(module, g, names, (enums) => enumValues(enums, headers, ios, sdkPath));
+	const schema = buildIosSchema(module, g, names, (enums) => enumValues(enums, headers, ios, sdkPath), cSwiftNames(modules.get(module) ? [...new Set(headers.map((h) => path.dirname(h)))] : [path.join(r.ios.frameworkDirs.get(module) ?? r.ios.frameworks, `${module}.framework/Headers`)]));
 	const umbrella = r.ios.umbrellas.get(module);
 	const framework = r.ios.frameworkDirs.get(module) ?? (modules.get(module) ? void 0 : r.ios.frameworks);
 	const inFramework = framework && frameworkUmbrella(framework, module);
@@ -8929,19 +9291,10 @@ let locatedByObject = /* @__PURE__ */ new WeakMap();
 function locate$1(platform, opts) {
 	const byObject = locatedByObject.get(opts)?.get(platform);
 	if (byObject) return byObject;
-	const found = locateByValue(platform, opts);
+	const found = platform === "android" ? locateAndroid(opts) : locateIos(opts);
 	locatedByObject.set(opts, (locatedByObject.get(opts) ?? /* @__PURE__ */ new Map()).set(platform, found));
 	return found;
 }
-function locateByValue(platform, opts) {
-	const k = `${platform}|${JSON.stringify(opts)}`;
-	let l = located$3.get(k);
-	if (!l) {
-		l = platform === "android" ? locateAndroid(opts) : locateIos(opts);
-		located$3.set(k, l);
-	}
-	return l;
-}
 function load$1(platform, r, module) {
 	if (!r.providers.has(module)) return { lookup: platform === "android" ? androidNotFound(r, module) : iosNotFound(r, module) };
 	const dir = path.join(r.scope, module);
@@ -9807,6 +10160,97 @@ function formatCType(t) {
 	}
 }
 //#endregion
+//#region ../compiler/src/package-versions.ts
+function compare$1(a, b) {
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		const d = (a[i] ?? 0) - (b[i] ?? 0);
+		if (d) return d;
+	}
+	return 0;
+}
+function pessimisticUpper(v) {
+	const head = v.length > 1 ? v.slice(0, -1) : [...v];
+	head[head.length - 1] += 1;
+	return head;
+}
+const POD_OPERATORS = {
+	"=": (v) => ({
+		lo: {
+			v,
+			inclusive: true
+		},
+		hi: {
+			v,
+			inclusive: true
+		}
+	}),
+	">=": (v) => ({ lo: {
+		v,
+		inclusive: true
+	} }),
+	">": (v) => ({ lo: {
+		v,
+		inclusive: false
+	} }),
+	"<=": (v) => ({ hi: {
+		v,
+		inclusive: true
+	} }),
+	"<": (v) => ({ hi: {
+		v,
+		inclusive: false
+	} }),
+	"~>": (v) => ({
+		lo: {
+			v,
+			inclusive: true
+		},
+		hi: {
+			v: pessimisticUpper(v),
+			inclusive: false
+		}
+	})
+};
+function intersect(a, b) {
+	const pick = (x, y, sign) => {
+		if (!x) return y;
+		if (!y) return x;
+		const d = compare$1(x.v, y.v) * sign;
+		if (d !== 0) return d > 0 ? x : y;
+		return {
+			v: x.v,
+			inclusive: x.inclusive && y.inclusive
+		};
+	};
+	return {
+		lo: pick(a.lo, b.lo, 1),
+		hi: pick(a.hi, b.hi, -1)
+	};
+}
+function isEmpty(r) {
+	if (!r.lo || !r.hi) return false;
+	const d = compare$1(r.lo.v, r.hi.v);
+	return d > 0 || d === 0 && !(r.lo.inclusive && r.hi.inclusive);
+}
+function podRange(requirement) {
+	let range = {};
+	for (const part of requirement.split(",")) {
+		const m = /^\s*(~>|>=|<=|>|<|=)?\s*(\d+(?:\.\d+)*)\s*$/.exec(part);
+		if (!m) return void 0;
+		range = intersect(range, POD_OPERATORS[m[1] ?? "="](m[2].split(".").map(Number)));
+	}
+	return range;
+}
+function podsCompatible(a, b) {
+	const ra = podRange(a);
+	const rb = podRange(b);
+	return !ra || !rb || !isEmpty(intersect(ra, rb));
+}
+function compareVersions(a, b) {
+	return compare$1(a.split(".").map(Number), b.split(".").map(Number));
+}
+const gradleCompatible = (a, b) => !a.endsWith("!!") && !b.endsWith("!!");
+//#endregion
 //#region ../compiler/src/sdk/schema.ts
 const MIN_IOS = "15.1";
 const JNI_PRIM$1 = {
@@ -9826,9 +10270,13 @@ function parseSdkType(s, module = "", typeParams = []) {
 }
 let sdkOptions = {};
 let deferredPlatforms = [];
+function oldestIos() {
+	const target = sdkOptions.ios?.deploymentTarget;
+	return target && compareVersions(target, "15.1") > 0 ? target : MIN_IOS;
+}
 function withSdkOptions(opts, f, deferred = []) {
 	const saved = [sdkOptions, deferredPlatforms];
-	sdkOptions = opts ?? {};
+	sdkOptions = { ...opts };
 	deferredPlatforms = deferred;
 	try {
 		return f();
@@ -9836,6 +10284,10 @@ function withSdkOptions(opts, f, deferred = []) {
 		[sdkOptions, deferredPlatforms] = saved;
 	}
 }
+const WRAP_UNBOUND = {
+	ios: "wrap it in Swift of your own whose types Lucent binds, in a local pod the app depends on",
+	android: "wrap it in Kotlin of your own whose types Lucent binds, in a Gradle module the app depends on"
+};
 function platformSdkTyped(platform) {
 	return !deferredPlatforms.includes(platform) && sdkAvailable(platform, sdkOptions);
 }
@@ -9862,6 +10314,9 @@ function sdkNamesOf(platform, module) {
 	const n = sdkNames(platform, module, sdkOptions);
 	return "names" in n ? n.names : void 0;
 }
+function sdkCacheDir() {
+	return sdkOptions.cacheDir;
+}
 function currentSdkIdentity() {
 	return sdkIdentity(sdkOptions);
 }
@@ -9904,6 +10359,7 @@ function jniDescriptor(params, returns, typeParams = []) {
 			case "id":
 			case "record":
 			case "set":
+			case "tuple":
 			case "out":
 			case "fn":
 			case "error": return fail$1(`${t.k} is not a Java type`);
@@ -9964,12 +10420,261 @@ function blockConversion(t) {
 		passed: true
 	}, sdkTypeFacts("ios"));
 }
+function kotlinFunctionConversion(t) {
+	return planConversion({
+		...t,
+		nullable: false
+	}, {
+		backend: "jni",
+		platform: "android",
+		flow: "in",
+		passed: true
+	}, sdkTypeFacts("android"));
+}
+//#endregion
+//#region ../compiler/src/sdk/view-rules.ts
+const ROOT_VIEW = {
+	ios: {
+		module: "UIKit",
+		name: "UIView"
+	},
+	android: {
+		module: "android.view",
+		name: "View"
+	}
+};
+const LISTENER = /^setOn([A-Z]\w*)Listener$/;
+const SETTER = /^set([A-Z]\w*)$/;
+const REGISTER = "addAction:forControlEvents:";
+const INSERT_AT = /^insert\w*:atIndex:$/;
+const capitalized = (s) => s[0].toUpperCase() + s.slice(1);
+const decapitalized = (s) => s[0].toLowerCase() + s.slice(1);
+const singleBit = (value) => typeof value === "number" && value > 0 && (value & value - 1) === 0;
+function referenced(type, schema, find) {
+	if (type.k !== "ref") return void 0;
+	const decl = type.module === schema.module ? schema.types.find((t) => t.name === type.name) : find(type.module, type.name);
+	return {
+		module: type.module,
+		name: type.name,
+		decl
+	};
+}
+function viewRules(cls, schema, find) {
+	const types = ownTypes(schema);
+	const where = schema.provenance?.artifact ?? schema.module;
+	const why = (member, role) => unsupportedReason(planBinding(cls, member, schema, types, role));
+	const props = [];
+	const events = [];
+	const refused = [];
+	for (const p of cls.properties ?? []) {
+		if (p.static || p.readonly || p.value !== void 0) continue;
+		const reason = why(p, "set");
+		if (reason) refused.push({
+			name: p.name,
+			reason
+		});
+		else props.push({
+			kind: "property",
+			name: p.name,
+			member: p,
+			explanation: `${cls.name}.${p.name}: a writable property${p.setter ? ` (${p.setter})` : ""}, in ${where}`
+		});
+	}
+	const setters = /* @__PURE__ */ new Map();
+	let children;
+	for (const m of cls.methods ?? []) {
+		if (m.static) continue;
+		const [child, index] = m.params;
+		if (m.params.length === 2 && child.type.k === "ref" && index.type.k === "prim" && (schema.platform === "ios" ? !!m.selector && INSERT_AT.test(m.selector) : m.name === "addView" && child.type.module === ROOT_VIEW.android.module && child.type.name === ROOT_VIEW.android.name) && !children) {
+			children = {
+				insert: m,
+				explanation: `${cls.name}.${m.selector ?? m.name}: inserts a view at an index, in ${where}`
+			};
+			continue;
+		}
+		const listener = LISTENER.exec(m.name);
+		if (listener && m.params.length === 1) {
+			const name = `on${listener[1]}`;
+			const ref = referenced(m.params[0].type, schema, find);
+			const iface = ref?.decl?.kind === "class" ? ref.decl : void 0;
+			const method = iface?.functional ? iface.methods?.find((x) => x.name === iface.functional && x.abstract) : void 0;
+			if (!ref || !iface || !method) refused.push({
+				name,
+				reason: `${m.name}'s listener has more than one method: set it in setup code, with an object of a class implementing it`
+			});
+			else events.push({
+				kind: "listener",
+				name,
+				setter: m,
+				listener: {
+					module: ref.module,
+					name: ref.name
+				},
+				method,
+				explanation: `${cls.name}.${m.name}: a listener with one method (${ref.name}.${method.name}), in ${where}`
+			});
+			continue;
+		}
+		if (m.selector === REGISTER && m.params.length === 2) {
+			const ref = referenced(m.params[1].type, schema, find);
+			if (ref?.decl?.kind === "enum") for (const c of ref.decl.cases.filter((x) => singleBit(x.value))) events.push({
+				kind: "control",
+				name: `on${capitalized(c.name)}`,
+				register: m,
+				events: {
+					module: ref.module,
+					name: ref.name
+				},
+				value: c.value,
+				explanation: `${cls.name}.${REGISTER} with ${ref.name}.${c.name}: a control event, in ${where}`
+			});
+			continue;
+		}
+		const setter = SETTER.exec(m.name);
+		if (schema.platform === "android" && setter && m.params.length === 1 && m.returns.k === "prim" && m.returns.name === "void") {
+			const name = decapitalized(setter[1]);
+			setters.set(name, [...setters.get(name) ?? [], m]);
+		}
+	}
+	for (const [name, overloads] of setters) {
+		if (props.some((p) => p.name === name)) continue;
+		if (overloads.every((m) => m.typeParams?.length)) {
+			refused.push({
+				name,
+				reason: `${overloads[0].name} is generic, and an attribute gives no type for it`
+			});
+			continue;
+		}
+		const usable = overloads.filter((m) => !m.typeParams?.length && !why(m, "call"));
+		if (!usable.length) refused.push({
+			name,
+			reason: why(overloads[0], "call")
+		});
+		else props.push({
+			kind: "setter",
+			name,
+			overloads: usable,
+			explanation: `${cls.name}.${usable[0].name}: a setter taking one value, in ${where}`
+		});
+	}
+	return {
+		props,
+		events,
+		refused,
+		...children ? { children } : {}
+	};
+}
+function isViewClass(cls, schema, find) {
+	const root = ROOT_VIEW[schema.platform];
+	let owner = cls;
+	let module = schema.module;
+	for (let depth = 0; owner && depth < 64; depth++) {
+		if (module === root.module && owner.name === root.name) return true;
+		if (owner.interface || !owner.extends) return false;
+		const sup = parseSdkType(owner.extends, module);
+		if (sup.k !== "ref") return false;
+		if (sup.module === root.module && sup.name === root.name) return true;
+		if (sup.module !== module && schema.platform === "ios") return true;
+		const decl = sup.module === schema.module ? schema.types.find((t) => t.name === sup.name) : find(sup.module, sup.name);
+		owner = decl?.kind === "class" ? decl : void 0;
+		module = sup.module;
+	}
+	return false;
+}
+function viewConstruction(cls, schema, find) {
+	if (schema.platform === "android") {
+		const ctor = (cls.constructors ?? []).find((c) => !c.protected && c.params.length === 1 && c.params[0].type.k === "ref" && c.params[0].type.module === "android.content" && c.params[0].type.name === "Context");
+		return ctor ? {
+			kind: "context",
+			ctor,
+			owner: cls.name,
+			module: schema.module
+		} : {
+			kind: "create",
+			reason: `${cls.name} has no constructor taking only a Context`
+		};
+	}
+	let owner = cls;
+	let module = schema.module;
+	for (let depth = 0; owner && depth < 32; depth++) {
+		const ctors = owner.constructors ?? [];
+		const frame = ctors.find((c) => c.selector === "initWithFrame:");
+		const plain = ctors.find((c) => c.selector === "init" && !c.params.length);
+		if (frame) return {
+			kind: "frame",
+			ctor: frame,
+			owner: owner.name,
+			module
+		};
+		if (plain) return {
+			kind: "init",
+			ctor: plain,
+			owner: owner.name,
+			module
+		};
+		if (ctors.length && !owner.inheritsInit) break;
+		if (!owner.extends) break;
+		const sup = parseSdkType(owner.extends, module);
+		if (sup.k !== "ref") break;
+		const decl = sup.module === schema.module ? schema.types.find((t) => t.name === sup.name) : find(sup.module, sup.name);
+		owner = decl?.kind === "class" ? decl : void 0;
+		module = sup.module;
+	}
+	return {
+		kind: "create",
+		reason: `${cls.name} has no initWithFrame: or init to make it with: say how, create={() => new ${cls.name}(…)}`
+	};
+}
+function viewTag(cls, schema, moduleOf) {
+	const find = (module, name) => moduleOf(module)?.types.find((t) => t.name === name);
+	const props = /* @__PURE__ */ new Map();
+	const events = /* @__PURE__ */ new Map();
+	const refused = /* @__PURE__ */ new Map();
+	let children;
+	let owner = {
+		cls,
+		schema
+	};
+	for (let depth = 0; owner && depth < 64; depth++) {
+		const rules = viewRules(owner.cls, owner.schema, find);
+		for (const prop of rules.props) if (!props.has(prop.name)) props.set(prop.name, {
+			prop,
+			owner
+		});
+		for (const event of rules.events) if (!events.has(event.name)) events.set(event.name, {
+			event,
+			owner
+		});
+		if (rules.children && !children) children = {
+			rule: rules.children,
+			owner
+		};
+		for (const r of rules.refused) if (!refused.has(r.name)) refused.set(r.name, r.reason);
+		const root = ROOT_VIEW[schema.platform];
+		if (owner.schema.module === root.module && owner.cls.name === root.name) break;
+		if (!owner.cls.extends) break;
+		const sup = parseSdkType(owner.cls.extends, owner.schema.module);
+		const next = sup.k === "ref" ? moduleOf(sup.module) : void 0;
+		const decl = sup.k === "ref" ? next?.types.find((t) => t.name === sup.name) : void 0;
+		owner = next && decl?.kind === "class" ? {
+			cls: decl,
+			schema: next
+		} : void 0;
+	}
+	return {
+		props,
+		events,
+		...children ? { children } : {},
+		refused,
+		construction: viewConstruction(cls, schema, find)
+	};
+}
 //#endregion
 //#region ../compiler/src/sdk/dts.ts
-function sdkDts(schema) {
-	const plain = emitDts(schema, /* @__PURE__ */ new Map());
+function sdkDts(schema, options = {}) {
+	const plain = emitDts(schema, /* @__PURE__ */ new Map(), options);
 	const aliases = importAliases(schema, plain.imports);
-	return aliases.size ? emitDts(schema, aliases).text : plain.text;
+	return aliases.size ? emitDts(schema, aliases, options).text : plain.text;
 }
 function importAliases(schema, imports) {
 	const local = new Set(schema.types.map((t) => t.name));
@@ -9980,7 +10685,7 @@ function importAliases(schema, imports) {
 	return aliases;
 }
 const moduleIdent = (module) => module.replace(/^lucent:/, "").replace(/^(ios|android)\//, "").replace(/\W/g, "_");
-function emitDts(schema, aliases) {
+function emitDts(schema, aliases, options) {
 	const imports = /* @__PURE__ */ new Map();
 	const use = (module, name) => {
 		const names = imports.get(module) ?? /* @__PURE__ */ new Set();
@@ -10005,6 +10710,10 @@ function emitDts(schema, aliases) {
 					use("lucent:ios", "Out");
 					return ref("Out", tsType(t.of, true));
 				case "set": return ref("Set", tsType(t.of, out));
+				case "tuple": return tuple(t.of.map((x, i) => ({
+					type: tsType(x, out),
+					...t.labels ? { name: t.labels[i] } : {}
+				})));
 				case "array":
 					if (t.of.k === "prim" && t.of.name === "byte" && !t.list) return ref("Uint8Array");
 					return array(tsType(t.of, out));
@@ -10052,7 +10761,7 @@ function emitDts(schema, aliases) {
 			type: tsType(parseSdkType(f.type, schema.module))
 		})))
 	}, blank);
-	else body.push(...classDts(schema, type, tsType, use), blank);
+	else body.push(...classDts(schema, type, tsType, use, options), blank);
 	const refused = refusalDoc(schema);
 	for (const f of schema.functions ?? []) {
 		const tps = f.typeParams ?? [];
@@ -10223,7 +10932,7 @@ const RESERVED$3 = /* @__PURE__ */ new Set([
 function safeName(n) {
 	return RESERVED$3.has(n) ? `${n}_` : n;
 }
-function classDts(schema, cls, tsType, use) {
+function classDts(schema, cls, tsType, use, options) {
 	const parse = (s, tps = []) => parseSdkType(s, schema.module, tps);
 	const oneOf = (refs, type, out) => {
 		if (!refs) return tsType(type, out);
@@ -10316,10 +11025,12 @@ function classDts(schema, cls, tsType, use) {
 	const methodNames = new Set((cls.methods ?? []).map((m) => `${!!m.static}:${m.name}`));
 	for (const p of (cls.properties ?? []).filter((x) => !methodNames.has(`${!!x.static}:${x.name}`))) {
 		const type = p.value !== void 0 && p.static && p.readonly ? literal$3(constantValue$1(parse(p.type), p.value)) : settled(p, oneOf(p.oneOf, result(parse(p.type)), true));
+		const set = p.readonly || schema.platform !== "android" ? void 0 : oneOf(p.oneOf, parse(p.type), false);
 		members.push({
 			k: "property",
 			name: p.name,
 			type,
+			...set && printType(set) !== printType(type) ? { set } : {},
 			...p.static ? { static: true } : {},
 			...p.readonly ? { readonly: true } : {},
 			...memberDoc(p)
@@ -10384,6 +11095,23 @@ function classDts(schema, cls, tsType, use) {
 		params: [],
 		ret: keyword$1("void")
 	});
+	const jsx = options.jsx ? jsxAttributes(schema, cls, tsType, parse) : void 0;
+	if (jsx?.root) members.push({
+		k: "property",
+		name: "~jsx",
+		type: ref(use("lucent:ui", "NativeAttributes"), ref("this")),
+		readonly: true,
+		optional: true,
+		doc: "The JSX attributes of this view's tag: its classes' `~jsx:` keys, together."
+	});
+	if (jsx?.decl) members.push({
+		k: "property",
+		name: `~jsx:${schema.module}.${cls.name}`,
+		type: ref(jsx.name, ref("this"), ...typeParams.map((t) => ref(t.name))),
+		readonly: true,
+		optional: true,
+		doc: "The JSX attributes this class gives its tag, derived by rule from its declarations."
+	});
 	const out = [{
 		k: "class",
 		name: cls.name,
@@ -10401,8 +11129,63 @@ function classDts(schema, cls, tsType, use) {
 		extends: supers,
 		members: []
 	});
+	if (jsx?.decl) out.push(jsx.decl);
 	return out;
 }
+function jsxAttributes(schema, cls, tsType, parse) {
+	const find = (module, name) => findSdkType(schema.platform, module, name);
+	if (cls.interface || !isViewClass(cls, schema, find)) return void 0;
+	const view = ROOT_VIEW[schema.platform];
+	const root = schema.module === view.module && cls.name === view.name;
+	const rules = viewRules(cls, schema, find);
+	const childrenMember = (c) => {
+		const child = tsType(parseSdkType(`${view.module}.${view.name}`), false);
+		return {
+			k: "property",
+			name: "children",
+			type: union$1([child, readonlyArray(child)]),
+			optional: true,
+			doc: c.explanation
+		};
+	};
+	const name = `__jsx_${cls.name}`;
+	if (!rules.props.length && !rules.events.length && !rules.children) return root ? {
+		name,
+		root
+	} : void 0;
+	const props = rules.props.map((p) => ({
+		k: "property",
+		name: p.name,
+		type: p.kind === "property" ? tsType(parse(p.member.type), false) : union$1(p.overloads.map((m) => tsType(parse(m.params[0].type), false))),
+		optional: true,
+		doc: p.explanation
+	}));
+	const events = rules.events.map((e) => ({
+		k: "property",
+		name: e.name,
+		type: e.kind === "listener" ? fn$3(e.method.params.map((x, i) => param$2(`arg${i}`, tsType(parseSdkType(x.type, e.listener.module), true))), tsType(parseSdkType(e.method.returns, e.listener.module), false)) : fn$3([param$2("control", ref("Self"))], keyword$1("void")),
+		optional: true,
+		doc: e.explanation
+	}));
+	return {
+		name,
+		root,
+		decl: {
+			k: "interface",
+			name,
+			local: true,
+			typeParams: [{ name: "Self" }, ...distinctTypeParams(cls.typeParams ?? []).map((name) => ({
+				name,
+				default: keyword$1("unknown")
+			}))],
+			members: [
+				...props,
+				...events,
+				...rules.children ? [childrenMember(rules.children)] : []
+			]
+		}
+	};
+}
 function namedLikeAncestor(schema, cls) {
 	let ext = cls.extends ? parseSdkType(cls.extends, schema.module) : void 0;
 	for (let depth = 0; ext?.k === "ref" && depth < 32; depth++) {
@@ -10731,96 +11514,165 @@ function constantValue$1(t, value) {
 	return isBigIntType(t) ? BigInt(value) : value;
 }
 //#endregion
-//#region ../compiler/src/package-versions.ts
-function compare$1(a, b) {
-	for (let i = 0; i < Math.max(a.length, b.length); i++) {
-		const d = (a[i] ?? 0) - (b[i] ?? 0);
-		if (d) return d;
-	}
-	return 0;
+//#region ../compiler/src/sdk/declaration-cache.ts
+let version$1;
+function declarationsVersion() {
+	if (version$1) return version$1;
+	return version$1 = "df570a79";
+}
+function cachedDeclarations(cacheDir, identity, key, make) {
+	const name = crypto.createHash("sha256").update([
+		declarationsVersion(),
+		identity,
+		...key
+	].join("\n")).digest("hex").slice(0, 24);
+	const file = path.join(cacheRoot(cacheDir), "declarations", `${name}.d.ts`);
+	try {
+		return fs.readFileSync(file, "utf8");
+	} catch {}
+	const text = make();
+	const tmp = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	fs.writeFileSync(tmp, text);
+	fs.renameSync(tmp, file);
+	return text;
 }
-function pessimisticUpper(v) {
-	const head = v.length > 1 ? v.slice(0, -1) : [...v];
-	head[head.length - 1] += 1;
-	return head;
+//#endregion
+//#region ../compiler/src/sdk/native-jsx-dts.ts
+const NATIVE_JSX_UI = ["NativeViewTag"];
+function rootViews(platforms) {
+	const alias = (p) => `${p}_${ROOT_VIEW[p].name}`;
+	return {
+		imports: platforms.map((p) => ({
+			k: "importType",
+			names: [`${ROOT_VIEW[p].name} as ${alias(p)}`],
+			from: `lucent:${p}/${ROOT_VIEW[p].module}`
+		})),
+		types: platforms.map((p) => ref(alias(p)))
+	};
 }
-const POD_OPERATORS = {
-	"=": (v) => ({
-		lo: {
-			v,
-			inclusive: true
-		},
-		hi: {
-			v,
-			inclusive: true
-		}
-	}),
-	">=": (v) => ({ lo: {
-		v,
-		inclusive: true
-	} }),
-	">": (v) => ({ lo: {
-		v,
-		inclusive: false
-	} }),
-	"<=": (v) => ({ hi: {
-		v,
-		inclusive: true
-	} }),
-	"<": (v) => ({ hi: {
-		v,
-		inclusive: false
-	} }),
-	"~>": (v) => ({
-		lo: {
-			v,
-			inclusive: true
-		},
-		hi: {
-			v: pessimisticUpper(v),
-			inclusive: false
+const nativeTags = (roots) => roots.map((r) => ref("NativeViewTag", r));
+function nativeJsxDecls() {
+	return [{
+		k: "interface",
+		name: "ElementAttributesProperty",
+		members: [{
+			k: "property",
+			name: "~jsx",
+			type: object([])
+		}]
+	}, {
+		k: "interface",
+		name: "IntrinsicClassAttributes",
+		typeParams: [{ name: "T" }],
+		members: [{
+			k: "property",
+			name: "create",
+			type: fn$3([], ref("T")),
+			optional: true,
+			doc: "Makes the view, where its class has no frame or Context constructor to make it with."
+		}]
+	}];
+}
+//#endregion
+//#region ../compiler/src/sdk/declarations.ts
+function classOfDecl(decl) {
+	const sdk = sdkModuleOf(decl.getSourceFile());
+	if (!sdk) return void 0;
+	const owner = ts.isClassDeclaration(decl) ? decl : decl.parent;
+	if (!owner || !ts.isClassDeclaration(owner) || !owner.name) return void 0;
+	const cls = findSdkType(sdk.platform, sdk.module, owner.name.text);
+	return cls?.kind === "class" ? {
+		...sdk,
+		cls
+	} : void 0;
+}
+function sdkInterfacesOf(checker, decl) {
+	const out = [];
+	for (const h of decl.heritageClauses ?? []) {
+		if (h.token !== ts.SyntaxKind.ImplementsKeyword) continue;
+		for (const t of h.types) {
+			const d = checker.getTypeAtLocation(t).getSymbol()?.declarations?.find(ts.isClassDeclaration);
+			const ref = d ? classOfDecl(d) : void 0;
+			if (ref?.cls.interface) out.push(ref);
 		}
-	})
-};
-function intersect(a, b) {
-	const pick = (x, y, sign) => {
-		if (!x) return y;
-		if (!y) return x;
-		const d = compare$1(x.v, y.v) * sign;
-		if (d !== 0) return d > 0 ? x : y;
-		return {
-			v: x.v,
-			inclusive: x.inclusive && y.inclusive
+	}
+	return out;
+}
+function requirementOf(checker, m) {
+	const cls = m.parent;
+	if (!ts.isClassLike(cls) || !ts.isIdentifier(m.name)) return void 0;
+	for (const protocol of sdkInterfacesOf(checker, cls)) {
+		const method = protocol.cls.methods?.find((x) => !x.static && x.name === m.name.text);
+		if (method) return {
+			protocol,
+			method,
+			main: !!(protocol.cls.mainActor || method.mainActor)
 		};
+	}
+}
+function schemaMethod(ref, decl) {
+	const inherited = inheritedFrom(ref, decl);
+	if (inherited) return {
+		ref: inherited.ref,
+		method: inherited.ref.cls.methods[inherited.index],
+		promise: false
 	};
-	return {
-		lo: pick(a.lo, b.lo, 1),
-		hi: pick(a.hi, b.hi, -1)
-	};
+	const name = decl.name.text;
+	const index = decl.parent.members.filter((m) => ts.isMethodDeclaration(m) && m.name.text === name).indexOf(decl);
+	return (ref.cls.methods ?? []).flatMap((m) => [...m.name === name ? [{
+		ref,
+		method: m,
+		promise: false
+	}] : [], ...m.async && declaresPromise(ref.cls, m) && (m.async.name ?? m.name) === name ? [{
+		ref,
+		method: m,
+		promise: true
+	}] : []])[index];
 }
-function isEmpty(r) {
-	if (!r.lo || !r.hi) return false;
-	const d = compare$1(r.lo.v, r.hi.v);
-	return d > 0 || d === 0 && !(r.lo.inclusive && r.hi.inclusive);
+function schemaProperty(ref, decl) {
+	const inherited = inheritedFrom(ref, decl);
+	if (inherited) return {
+		ref: inherited.ref,
+		property: inherited.ref.cls.properties[inherited.index]
+	};
+	const name = decl.name.text;
+	const isStatic = !!ts.getModifiers(decl)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+	const property = ref.cls.properties?.find((p) => p.name === name && !!p.static === isStatic);
+	return property ? {
+		ref,
+		property
+	} : void 0;
 }
-function podRange(requirement) {
-	let range = {};
-	for (const part of requirement.split(",")) {
-		const m = /^\s*(~>|>=|<=|>|<|=)?\s*(\d+(?:\.\d+)*)\s*$/.exec(part);
-		if (!m) return void 0;
-		range = intersect(range, POD_OPERATORS[m[1] ?? "="](m[2].split(".").map(Number)));
-	}
-	return range;
+const isSdkPropertyDecl = (d) => ts.isPropertyDeclaration(d) || ts.isGetAccessorDeclaration(d) || ts.isSetAccessorDeclaration(d);
+function inheritedFrom(ref, decl) {
+	const tag = ts.getJSDocTags(decl).find((t) => `@${t.tagName.text}` === INHERITED_TAG);
+	if (!tag) return void 0;
+	const [owner, index] = (ts.getTextOfJSDocComment(tag.comment) ?? "").split(" ");
+	const dot = owner.lastIndexOf(".");
+	const module = owner.slice(0, dot);
+	const cls = findSdkType(ref.platform, module, owner.slice(dot + 1));
+	if (cls?.kind !== "class") throw new Error(`${owner}: no class for an inherited member`);
+	return {
+		ref: {
+			...ref,
+			module,
+			cls
+		},
+		index: Number(index)
+	};
 }
-function podsCompatible(a, b) {
-	const ra = podRange(a);
-	const rb = podRange(b);
-	return !ra || !rb || !isEmpty(intersect(ra, rb));
+function schemaConstructor(ref, decl) {
+	return ref.cls.constructors[decl.parent.members.filter(ts.isConstructorDeclaration).indexOf(decl)];
 }
-function compareVersions(a, b) {
-	return compare$1(a.split(".").map(Number), b.split(".").map(Number));
+function promiseForm(m) {
+	const { throws: _, ...rest } = m;
+	return {
+		...rest,
+		params: m.params.slice(0, -1),
+		returns: m.async.returns
+	};
 }
-const gradleCompatible = (a, b) => !a.endsWith("!!") && !b.endsWith("!!");
 //#endregion
 //#region ../compiler/src/sdk/toolkit-forms.ts
 const FORMS = { SwiftUI: [{
@@ -10945,7 +11797,7 @@ function toolkitDts(toolkit, schema) {
 	const overloads = (owner, m, name) => {
 		const refused = unsupportedReason(planBinding(owner, m, schema, ownTypes(schema)));
 		const since = String(m.since ?? owner?.since ?? "0");
-		const newer = compareVersions(since, MIN_IOS) > 0;
+		const newer = compareVersions(since, oldestIos()) > 0;
 		const doc = (form) => [
 			...refused ? [`Lucent cannot write this in a body yet: ${refused}.`] : [],
 			...m.deprecated ? ["@deprecated"] : [],
@@ -11172,11 +12024,12 @@ function toolkitDts(toolkit, schema) {
 	return printUnit({
 		banner: `Generated by Lucent from ${schema.provenance?.artifact ?? schema.module} (${schema.module}, written as source). Do not edit.`,
 		decls: [
-			...forms.size ? [{
+			{
 				k: "importType",
-				names: [...forms].sort(),
+				names: [.../* @__PURE__ */ new Set([...forms, ...NATIVE_JSX_UI])].sort(),
 				from: "lucent:ui"
-			}] : [],
+			},
+			...rootViews([toolkit.platform]).imports,
 			...decls,
 			...modifierDecls,
 			...namespaces,
@@ -11318,6 +12171,7 @@ const method = (o) => ({
 });
 function fixedDecls(toolkit) {
 	const view = ref(toolkit.source.view);
+	const [root] = rootViews([toolkit.platform]).types;
 	const shown = union$1([
 		view,
 		literal$3(false),
@@ -11353,8 +12207,14 @@ function fixedDecls(toolkit) {
 				{
 					k: "typeAlias",
 					name: "Element",
-					type: view
+					type: intersection([view, root])
+				},
+				{
+					k: "typeAlias",
+					name: "ElementType",
+					type: union$1([fn$3([param$2("props", keyword$1("never"))], view), ...nativeTags([root])])
 				},
+				...nativeJsxDecls(),
 				{
 					k: "interface",
 					name: "ElementChildrenAttribute",
@@ -11555,164 +12415,6 @@ function toolkit(name) {
 	return TOOLKITS[name];
 }
 //#endregion
-//#region ../compiler/src/ui/roots.ts
-const ROOT_VIEWS = {
-	ios: {
-		module: "UIKit",
-		name: "UIView"
-	},
-	android: {
-		module: "android.view",
-		name: "View"
-	}
-};
-const SLOT_VIEWS = {
-	ios: {
-		module: "UIKit",
-		name: "UIView"
-	},
-	android: {
-		module: "android.view",
-		name: "ViewGroup"
-	}
-};
-const sdkClassOf = (classes) => (decl) => {
-	const sdk = sdkModuleOf(decl.getSourceFile());
-	const found = sdk && classes[sdk.platform];
-	return found && found.module === sdk.module && decl.name?.text === found.name ? sdk.platform : void 0;
-};
-function toolkitOf(root) {
-	const toolkit = toolkitOfModule(root.module);
-	return toolkit && TOOLKITS[toolkit].root === root.name ? toolkit : void 0;
-}
-const sdkRootView = sdkClassOf(ROOT_VIEWS);
-const sdkRoot = (decl) => {
-	const builtin = builtinSdkModuleOf(decl.getSourceFile());
-	const toolkit = builtin && toolkitOf({
-		module: builtin,
-		name: decl.name?.text ?? ""
-	});
-	return toolkit ? TOOLKITS[toolkit].platform : sdkRootView(decl);
-};
-const sdkSlot = sdkClassOf(SLOT_VIEWS);
-function returnShape(checker, fn, platform, rootOf) {
-	const signature = checker.getSignatureFromDeclaration(fn);
-	const declared = signature ? checker.getReturnTypeOfSignature(signature) : void 0;
-	const promised = declared && promisedType(checker, declared);
-	const viewOf = (t) => viewClass(checker, t, rootOf);
-	const isView = (t) => {
-		const found = viewOf(t);
-		return found && (!platform || found.platform === platform) ? found.decl : void 0;
-	};
-	if (promised) return members(promised).some(isView) ? { kind: "promised" } : { kind: "value" };
-	const returned = returnedExpressions(checker, fn, platform).map((e) => checker.getTypeAtLocation(e));
-	const types = (fn.body ? returned : declared ? [declared] : []).flatMap(members);
-	const views = [];
-	let other;
-	let viewName = "";
-	for (const t of types) {
-		if (t.flags & ts.TypeFlags.Any || viewOf(t) && !isView(t)) continue;
-		const cls = isView(t);
-		if (cls) {
-			views.push(cls);
-			viewName ||= checker.typeToString(t);
-		} else other ??= checker.typeToString(t);
-	}
-	if (!views.length) return { kind: "value" };
-	if (other !== void 0) return {
-		kind: "ambiguous",
-		view: viewName,
-		other
-	};
-	return {
-		kind: "view",
-		root: commonClass(checker, views)
-	};
-}
-function classIdentity(checker, returned) {
-	const decl = ancestors(checker, returned).find((c) => c.getSourceFile().isDeclarationFile) ?? returned;
-	const sf = decl.getSourceFile();
-	return {
-		module: sdkModuleOf(sf)?.module ?? builtinSdkModuleOf(sf) ?? path.basename(sf.fileName, ".d.ts"),
-		name: decl.name?.text ?? ""
-	};
-}
-function members(t) {
-	return t.isUnion() ? t.types.flatMap(members) : elementsOf(t) ?? [t];
-}
-function elementsOf(t) {
-	if (!t.isIntersection()) return void 0;
-	return t.types.every((m) => {
-		const decl = m.getSymbol()?.declarations?.[0];
-		return !!decl && ts.isInterfaceDeclaration(decl) && !!toolkitElement(decl);
-	}) ? t.types : void 0;
-}
-function promisedType(checker, t) {
-	const name = t.getSymbol()?.getName();
-	if (name !== "Promise" && name !== "PromiseLike") return void 0;
-	return checker.getTypeArguments(t)[0];
-}
-function viewClass(checker, t, rootOf) {
-	const decl = t.getSymbol()?.declarations?.[0];
-	if (decl && ts.isInterfaceDeclaration(decl)) return toolkitElement(decl);
-	if (!decl || !ts.isClassDeclaration(decl)) return void 0;
-	for (const c of ancestors(checker, decl)) {
-		const platform = rootOf(c);
-		if (platform) return {
-			decl,
-			platform
-		};
-	}
-}
-function toolkitElement(decl) {
-	const sf = decl.getSourceFile();
-	const name = toolkitOfModule(builtinSdkModuleOf(sf));
-	const found = name && toolkit(name);
-	if (!found || found.element !== decl.name.text) return void 0;
-	const root = sf.statements.find((s) => ts.isClassDeclaration(s) && s.name?.text === found.root);
-	return root && {
-		decl: root,
-		platform: found.platform
-	};
-}
-function toolkitRootType(checker, t) {
-	const [first] = elementsOf(t) ?? [t];
-	const decl = first?.getSymbol()?.declarations?.[0];
-	const root = decl && ts.isInterfaceDeclaration(decl) ? toolkitElement(decl) : void 0;
-	return root?.decl.name && checker.getTypeAtLocation(root.decl.name);
-}
-function ancestors(checker, decl) {
-	const out = [];
-	for (let c = decl; c && !out.includes(c); c = baseClass(checker, c)) out.push(c);
-	return out;
-}
-function baseClass(checker, c) {
-	const symbol = c.name && checker.getSymbolAtLocation(c.name);
-	if (!symbol) return void 0;
-	const type = checker.getDeclaredTypeOfSymbol(symbol);
-	const base = checker.getBaseTypes(type)[0]?.getSymbol()?.declarations?.[0];
-	return base && ts.isClassDeclaration(base) ? base : void 0;
-}
-function commonClass(checker, classes) {
-	const [first, ...rest] = classes;
-	const others = rest.map((c) => ancestors(checker, c));
-	return ancestors(checker, first).find((c) => others.every((a) => a.includes(c))) ?? first;
-}
-function returnedExpressions(checker, fn, platform) {
-	if (!fn.body) return [];
-	if (!ts.isBlock(fn.body)) return [fn.body];
-	const out = [];
-	const visit = (n) => {
-		if (ts.isFunctionLike(n)) return;
-		const branch = platform && branchPlatform(checker, n);
-		if (branch && branch !== platform) return;
-		if (ts.isReturnStatement(n) && n.expression) out.push(n.expression);
-		ts.forEachChild(n, visit);
-	};
-	ts.forEachChild(fn.body, visit);
-	return out;
-}
-//#endregion
 //#region ../compiler/src/types.ts
 const T = {
 	number: { k: "number" },
@@ -13599,6 +14301,11 @@ function toolkitTypesPath(name) {
 	return toolkitSource(name) ? path.join(SDK_ROOT, "toolkit", `${name}.d.ts`) : sdkLibPath(name);
 }
 const toolkitTexts = /* @__PURE__ */ new WeakMap();
+const sdkTexts = {
+	plain: /* @__PURE__ */ new WeakMap(),
+	jsx: /* @__PURE__ */ new WeakMap()
+};
+const stubTexts = /* @__PURE__ */ new WeakMap();
 function toolkitDeclarations(name) {
 	const toolkit = TOOLKITS[name];
 	const source = toolkitSource(name);
@@ -13636,11 +14343,26 @@ function virtualSdkText(file, direct) {
 	const module = m[2];
 	if (platform === "ios" && !direct.has(`${platform}/${module}`)) {
 		const names = sdkNamesOf(platform, module);
-		return names ? stubDts(platform, module, names) : void 0;
+		if (!names) return void 0;
+		let stub = stubTexts.get(names);
+		if (stub === void 0) stubTexts.set(names, stub = cachedDeclarations(sdkCacheDir(), currentSdkIdentity(), [
+			"names",
+			platform,
+			module
+		], () => stubDts(platform, module, names)));
+		return stub;
 	}
 	const schema = findSdkModule(platform, module);
 	if (!schema) return void 0;
-	const text = sdkDts(schema);
+	const jsx = fabricRequested();
+	const texts = sdkTexts[jsx ? "jsx" : "plain"];
+	let text = texts.get(schema);
+	if (text === void 0) texts.set(schema, text = cachedDeclarations(sdkCacheDir(), currentSdkIdentity(), [
+		"full",
+		platform,
+		module,
+		...jsx ? ["jsx"] : []
+	], () => sdkDts(schema, { jsx })));
 	for (const r of text.matchAll(/^export \* from "lucent:(ios\/_\w+)";$/gm)) direct.add(r[1]);
 	return text;
 }
@@ -13774,6 +14496,7 @@ function jsxRuntimeOf(specifier, file) {
 function jsxRuntimeText() {
 	const typed = Object.keys(TOOLKITS).filter((t) => platformSdkTyped(TOOLKITS[t].platform));
 	const elements = typed.map((t) => TOOLKITS[t].element);
+	const { imports: rootImports, types: roots } = rootViews(PLATFORMS.filter((p) => platformSdkTyped(p)));
 	return printUnit({
 		banner: "The JSX of a shared Lucent file: each platform's toolkit's, in its code.",
 		decls: [
@@ -13782,6 +14505,12 @@ function jsxRuntimeText() {
 				names: [TOOLKITS[t].element],
 				from: `lucent:${t}`
 			})),
+			{
+				k: "importType",
+				names: NATIVE_JSX_UI,
+				from: "lucent:ui"
+			},
+			...rootImports,
 			{
 				k: "namespace",
 				name: "JSX",
@@ -13789,13 +14518,18 @@ function jsxRuntimeText() {
 					{
 						k: "typeAlias",
 						name: "Element",
-						type: elements.length ? intersection(elements.map((e) => ref(e))) : keyword$1("unknown")
+						type: elements.length || roots.length ? intersection([...elements.map((e) => ref(e)), ...roots]) : keyword$1("unknown")
 					},
 					{
 						k: "typeAlias",
 						name: "ElementType",
-						type: union$1([...elements.map((e) => fn$3([param$2("props", keyword$1("never"))], ref(e))), ...typed.length < Object.keys(TOOLKITS).length ? [fn$3([param$2("props", keyword$1("never"))], keyword$1("unknown"))] : []])
+						type: union$1([
+							...elements.map((e) => fn$3([param$2("props", keyword$1("never"))], ref(e))),
+							...typed.length < Object.keys(TOOLKITS).length ? [fn$3([param$2("props", keyword$1("never"))], keyword$1("unknown"))] : [],
+							...nativeTags(roots)
+						])
 					},
+					...nativeJsxDecls(),
 					{
 						k: "interface",
 						name: "ElementChildrenAttribute",
@@ -13823,7 +14557,8 @@ function createLucentProgram(files, readSource, platform, extra = {}) {
 		...compilerOptions(),
 		skipLibCheck: !extra.libCheck
 	};
-	const host = compilerHost(options, readSource, directSdkImports(files, readSource));
+	const direct = directSdkImports(files, readSource);
+	const host = compilerHost(options, readSource, direct);
 	const program = ts.createProgram([
 		...files.map((f) => path.resolve(f)),
 		...references.map((f) => path.resolve(f)),
@@ -13864,7 +14599,13 @@ function createLucentProgram(files, readSource, platform, extra = {}) {
 		diagnostics.push(...bad);
 		for (const d of [...program.getSyntacticDiagnostics(sf), ...program.getSemanticDiagnostics(sf)]) {
 			if (d.code === 2307 && bad.some((b) => b.start !== void 0 && d.start !== void 0 && d.start >= b.start && d.start < b.start + (b.length ?? 0))) continue;
-			diagnostics.push(fromTs(d));
+			const hint = nativeMemberHint(d, checker, direct) ?? nativeAttributeHint(d, checker) ?? initializerFactoryHint(d, checker) ?? inheritedInitializerHint(d, checker, direct);
+			const diagnostic = fromTs(d);
+			diagnostics.push(hint ? {
+				...diagnostic,
+				message: `${diagnostic.message} ${hint.message}`,
+				fix: hint.fix
+			} : diagnostic);
 		}
 	}
 	return {
@@ -13875,6 +14616,129 @@ function createLucentProgram(files, readSource, platform, extra = {}) {
 		diagnostics
 	};
 }
+const MISSING_MEMBER = /* @__PURE__ */ new Set([2339, 2551]);
+function nativeMemberHint(d, checker, direct) {
+	if (!MISSING_MEMBER.has(d.code) || !d.file || d.start === void 0) return void 0;
+	const name = nodeAt(d.file, d.start);
+	const access = name.parent;
+	if (!ts.isIdentifier(name) || !access || !ts.isPropertyAccessExpression(access)) return void 0;
+	const type = checker.getTypeAtLocation(access.expression);
+	const symbol = type.getSymbol() ?? type.aliasSymbol;
+	const declared = symbol?.declarations?.[0]?.getSourceFile();
+	const sdk = declared && sdkModuleOf(declared);
+	if (!symbol || !sdk) return void 0;
+	const spec = `lucent:${sdk.platform}/${sdk.module}`;
+	if (sdk.platform === "ios" && !direct.has(`${sdk.platform}/${sdk.module}`)) return {
+		message: `${symbol.name} is ${spec}'s, which no file imports: only its name is known.`,
+		fix: `import from ${spec} (a type import is enough) to use ${symbol.name}'s members`
+	};
+	const found = sdkLookup(sdk.platform, sdk.module);
+	const schema = "schema" in found ? found.schema : void 0;
+	const provenance = schema?.provenance;
+	if (!schema || !provenance) return void 0;
+	const skipped = skippedMember(schema, symbol.name, name.text);
+	if (skipped) return {
+		message: `${skipped.api} is in ${provenance.artifact}, but Lucent does not bind it: ${skipped.reason}.`,
+		fix: WRAP_UNBOUND[sdk.platform]
+	};
+	if (provenance.kind === "sdk") return void 0;
+	return {
+		message: `${symbol.name} is ${spec}'s, from ${provenance.artifact} as installed, which has no ${name.text}.`,
+		fix: `use what ${symbol.name} declares in this version of ${sdk.module}, or install a version that has ${name.text}`
+	};
+}
+const PROTECTED_CONSTRUCTOR = 2674;
+function inheritedInitializerHint(d, checker, direct) {
+	if (d.code !== PROTECTED_CONSTRUCTOR && !NO_OVERLOAD.has(d.code)) return void 0;
+	if (!d.file || d.start === void 0) return void 0;
+	let at = nodeAt(d.file, d.start);
+	while (at && !ts.isNewExpression(at)) at = at.parent;
+	if (!at || !ts.isNewExpression(at)) return void 0;
+	const named = checker.getSymbolAtLocation(at.expression);
+	const symbol = named && named.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(named) : named;
+	const declared = symbol?.declarations?.[0]?.getSourceFile();
+	const sdk = declared && sdkModuleOf(declared);
+	if (!symbol || !sdk) return void 0;
+	let module = sdk.module;
+	let name = symbol.name;
+	for (let depth = 0; depth < 32; depth++) {
+		const found = sdkLookup(sdk.platform, module);
+		const cls = "schema" in found ? found.schema.types.find((t) => t.kind === "class" && t.name === name) : void 0;
+		if (cls?.kind !== "class" || cls.constructors?.length || !cls.inheritsInit || !cls.extends) break;
+		const up = parseSdkType(cls.extends, module);
+		if (up.k !== "ref") break;
+		[module, name] = [up.module, up.name];
+		const spec = `lucent:${sdk.platform}/${module}`;
+		if (module !== sdk.module && !direct.has(`${sdk.platform}/${module}`)) return {
+			message: `${symbol.name}'s initializers are ${name}'s, inherited from ${spec}, which no file imports: only its name is known.`,
+			fix: `import "${spec}" (a bare import is enough) to make a ${symbol.name} with ${name}'s initializers`
+		};
+	}
+}
+const NO_OVERLOAD = /* @__PURE__ */ new Set([
+	2554,
+	2769,
+	2345
+]);
+function initializerFactoryHint(d, checker) {
+	if (!NO_OVERLOAD.has(d.code) || !d.file || d.start === void 0) return void 0;
+	let at = nodeAt(d.file, d.start);
+	while (at && !ts.isNewExpression(at)) at = at.parent;
+	if (!at || !ts.isNewExpression(at)) return void 0;
+	const named = checker.getSymbolAtLocation(at.expression);
+	const symbol = named && named.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(named) : named;
+	const declared = symbol?.declarations?.[0]?.getSourceFile();
+	const sdk = declared && sdkModuleOf(declared);
+	if (!symbol || !sdk) return void 0;
+	const found = sdkLookup(sdk.platform, sdk.module);
+	const cls = "schema" in found ? found.schema.types.find((t) => t.kind === "class" && t.name === symbol.name) : void 0;
+	const factories = cls?.kind === "class" ? (cls.methods ?? []).filter((m) => m.static && m.swift?.name.startsWith("init(")) : [];
+	if (!factories.length) return void 0;
+	const listed = factories.map((f) => `${symbol.name}.${f.name}(…) for ${f.swift.name}`);
+	return {
+		message: `${symbol.name}'s initializers that take the same types are its static factories, which TypeScript tells apart: ${listed.join(", ")}.`,
+		fix: `call the one you mean: ${symbol.name}.${factories[0].name}(…)`
+	};
+}
+function skippedMember(schema, owner, member) {
+	for (const entry of schema.skipped ?? []) {
+		const at = entry.indexOf(": ");
+		const api = entry.slice(0, at);
+		const [type, name] = api.split("(")[0].split(/\.(?=[^.]*$)/);
+		if (name === member && (type === owner || type?.endsWith(`.${owner}`))) return {
+			api,
+			reason: entry.slice(at + 2)
+		};
+	}
+}
+function nativeAttributeHint(d, checker) {
+	if (!MISSING_ATTRIBUTE.has(d.code) || !d.file || d.start === void 0) return void 0;
+	let element = nodeAt(d.file, d.start);
+	while (element && !ts.isJsxOpeningElement(element) && !ts.isJsxSelfClosingElement(element)) element = element.parent;
+	if (!element) return void 0;
+	const decl = nativeTagType(checker, ts.isJsxOpeningElement(element) ? element.parent : element)?.getSymbol()?.declarations?.[0];
+	const ref = decl && classOfDecl(decl);
+	const schema = ref && findSdkModule(ref.platform, ref.module);
+	if (!ref || !schema) return void 0;
+	const tag = viewTag(ref.cls, schema, (m) => findSdkModule(ref.platform, m));
+	for (const a of element.attributes.properties) {
+		const name = ts.isJsxAttribute(a) ? a.name.getText() : void 0;
+		const reason = name && tag.refused.get(name);
+		if (reason) return {
+			message: `<${ref.cls.name}> does not take ${name}: ${reason}.`,
+			fix: `call it in setup code, on the view made with create={() => new ${ref.cls.name}(…)}`
+		};
+	}
+}
+const MISSING_ATTRIBUTE = /* @__PURE__ */ new Set([2322, 2769]);
+function nodeAt(sf, pos) {
+	let node = sf;
+	for (let inner = sf; inner;) {
+		node = inner;
+		inner = ts.forEachChild(node, (c) => c.getStart(sf) <= pos && pos < c.getEnd() ? c : void 0);
+	}
+	return node;
+}
 function importDiagnostics(sf, platform) {
 	const shared = !platformOf(sf.fileName);
 	const out = [];
@@ -14026,6 +14890,12 @@ function conformsByRoot(checker, impl, declared) {
 	const typeOf = (p) => checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration ?? p.declarations[0]);
 	return checker.isTypeAssignableTo(root, checker.getReturnTypeOfSignature(d)) && i.parameters.every((p, k) => checker.isTypeAssignableTo(typeOf(d.parameters[k]), typeOf(p)));
 }
+function described(checker, t) {
+	const [sig, ...more] = t.getCallSignatures();
+	const elements = sig && !more.length ? elementsOf(sig.getReturnType()) : void 0;
+	if (!sig || !elements) return checker.typeToString(t);
+	return `(${sig.parameters.map((p) => `${p.name}: ${checker.typeToString(checker.getTypeOfSymbol(p))}`).join(", ")}) => ${elements.map((e) => checker.typeToString(e)).join(" & ")}`;
+}
 function conformanceErrors(lp) {
 	const checker = lp.checker;
 	const out = [];
@@ -14056,7 +14926,7 @@ function conformanceErrors(lp) {
 			if (!decl || !declared) continue;
 			const implType = checker.getTypeOfSymbolAtLocation(i, decl);
 			const declType = checker.getTypeOfSymbolAtLocation(d, declared);
-			if (!checker.isTypeAssignableTo(implType, declType) && !conformsByRoot(checker, implType, declType)) out.push(at$2(decl, `${d.name} in ${implName} has type ${checker.typeToString(implType)}, which does not match ${checker.typeToString(declType)} declared in ${declName}`));
+			if (!checker.isTypeAssignableTo(implType, declType) && !conformsByRoot(checker, implType, declType)) out.push(at$2(decl, `${d.name} in ${implName} has type ${described(checker, implType)}, which does not match ${checker.typeToString(declType)} declared in ${declName}`));
 		}
 		for (const extra of impl.values()) {
 			const decl = extra.valueDeclaration ?? extra.declarations?.[0];
@@ -14320,11 +15190,7 @@ function inUntypedPlatformCode(lp, d, untyped) {
 	if (d.code !== Codes.TypeScript || !d.file || d.start === void 0 || !untyped.length || platformOf(d.file)) return false;
 	const sf = lp.program.getSourceFile(path.resolve(d.file));
 	if (!sf) return false;
-	let node = sf;
-	for (let inner = sf; inner;) {
-		node = inner;
-		inner = ts.forEachChild(node, (c) => c.getStart(sf) <= d.start && d.start < c.getEnd() ? c : void 0);
-	}
+	const node = nodeAt(sf, d.start);
 	const stmt = sf.statements.find((s) => s.getStart(sf) <= d.start && d.start < s.getEnd());
 	const p = (ts.isIdentifier(node) ? importedFrom(sf, node.text) : void 0) ?? branchPlatform(lp.checker, node) ?? (stmt ? platformScopes(lp.checker, sf).platforms.get(stmt) : void 0);
 	return !!p && untyped.includes(p);
@@ -14342,6 +15208,179 @@ function importedFrom(sf, name) {
 	}
 }
 //#endregion
+//#region ../compiler/src/ui/roots.ts
+const ROOT_VIEWS = {
+	ios: {
+		module: "UIKit",
+		name: "UIView"
+	},
+	android: {
+		module: "android.view",
+		name: "View"
+	}
+};
+const SLOT_VIEWS = {
+	ios: {
+		module: "UIKit",
+		name: "UIView"
+	},
+	android: {
+		module: "android.view",
+		name: "ViewGroup"
+	}
+};
+const sdkClassOf = (classes) => (decl) => {
+	const sdk = sdkModuleOf(decl.getSourceFile());
+	const found = sdk && classes[sdk.platform];
+	return found && found.module === sdk.module && decl.name?.text === found.name ? sdk.platform : void 0;
+};
+function toolkitOf(root) {
+	const toolkit = toolkitOfModule(root.module);
+	return toolkit && TOOLKITS[toolkit].root === root.name ? toolkit : void 0;
+}
+const sdkRootView = sdkClassOf(ROOT_VIEWS);
+const sdkRoot = (decl) => {
+	const builtin = builtinSdkModuleOf(decl.getSourceFile());
+	const toolkit = builtin && toolkitOf({
+		module: builtin,
+		name: decl.name?.text ?? ""
+	});
+	return toolkit ? TOOLKITS[toolkit].platform : sdkRootView(decl);
+};
+const sdkSlot = sdkClassOf(SLOT_VIEWS);
+function returnShape(checker, fn, platform, rootOf) {
+	const signature = checker.getSignatureFromDeclaration(fn);
+	const declared = signature ? checker.getReturnTypeOfSignature(signature) : void 0;
+	const promised = declared && promisedType(checker, declared);
+	const viewOf = (t) => viewClass(checker, t, rootOf);
+	const isView = (t) => {
+		const found = viewOf(t);
+		return found && (!platform || found.platform === platform) ? found.decl : void 0;
+	};
+	if (promised) return members(promised).some(isView) ? { kind: "promised" } : { kind: "value" };
+	const returned = returnedExpressions(checker, fn, platform).map((e) => nativeTagType(checker, e) ?? checker.getTypeAtLocation(e));
+	const types = (fn.body ? returned : declared ? [declared] : []).flatMap(members);
+	const views = [];
+	let other;
+	let viewName = "";
+	for (const t of types) {
+		if (t.flags & ts.TypeFlags.Any || viewOf(t) && !isView(t)) continue;
+		const cls = isView(t);
+		if (cls) {
+			views.push(cls);
+			viewName ||= checker.typeToString(t);
+		} else other ??= checker.typeToString(t);
+	}
+	if (!views.length) return { kind: "value" };
+	if (other !== void 0) return {
+		kind: "ambiguous",
+		view: viewName,
+		other
+	};
+	return {
+		kind: "view",
+		root: commonClass(checker, views)
+	};
+}
+function classIdentity(checker, returned) {
+	const decl = ancestors(checker, returned).find((c) => c.getSourceFile().isDeclarationFile) ?? returned;
+	const sf = decl.getSourceFile();
+	return {
+		module: sdkModuleOf(sf)?.module ?? builtinSdkModuleOf(sf) ?? path.basename(sf.fileName, ".d.ts"),
+		name: decl.name?.text ?? ""
+	};
+}
+function members(t) {
+	return t.isUnion() ? t.types.flatMap(members) : elementsOf(t) ?? [t];
+}
+function elementsOf(t) {
+	if (!t.isIntersection()) return void 0;
+	const declOf = (m) => m.getSymbol()?.declarations?.[0];
+	const elements = t.types.filter((m) => {
+		const decl = declOf(m);
+		return !!decl && ts.isInterfaceDeclaration(decl) && !!toolkitElement(decl);
+	});
+	const views = t.types.filter((m) => !elements.includes(m)).every((m) => {
+		const decl = declOf(m);
+		return !!decl && ts.isClassDeclaration(decl) && !!sdkRootView(decl);
+	});
+	return elements.length && views ? elements : void 0;
+}
+function nativeTagType(checker, e) {
+	let jsx = e;
+	while (ts.isParenthesizedExpression(jsx)) jsx = jsx.expression;
+	const tag = ts.isJsxElement(jsx) ? jsx.openingElement.tagName : ts.isJsxSelfClosingElement(jsx) ? jsx.tagName : void 0;
+	const symbol = tag && checker.getSymbolAtLocation(tag);
+	const target = symbol && symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+	const decl = target?.declarations?.[0];
+	return decl && ts.isClassDeclaration(decl) ? checker.getDeclaredTypeOfSymbol(target) : void 0;
+}
+function promisedType(checker, t) {
+	const name = t.getSymbol()?.getName();
+	if (name !== "Promise" && name !== "PromiseLike") return void 0;
+	return checker.getTypeArguments(t)[0];
+}
+function viewClass(checker, t, rootOf) {
+	const decl = t.getSymbol()?.declarations?.[0];
+	if (decl && ts.isInterfaceDeclaration(decl)) return toolkitElement(decl);
+	if (!decl || !ts.isClassDeclaration(decl)) return void 0;
+	for (const c of ancestors(checker, decl)) {
+		const platform = rootOf(c);
+		if (platform) return {
+			decl,
+			platform
+		};
+	}
+}
+function toolkitElement(decl) {
+	const sf = decl.getSourceFile();
+	const name = toolkitOfModule(builtinSdkModuleOf(sf));
+	const found = name && toolkit(name);
+	if (!found || found.element !== decl.name.text) return void 0;
+	const root = sf.statements.find((s) => ts.isClassDeclaration(s) && s.name?.text === found.root);
+	return root && {
+		decl: root,
+		platform: found.platform
+	};
+}
+function toolkitRootType(checker, t) {
+	const [first] = elementsOf(t) ?? [t];
+	const decl = first?.getSymbol()?.declarations?.[0];
+	const root = decl && ts.isInterfaceDeclaration(decl) ? toolkitElement(decl) : void 0;
+	return root?.decl.name && checker.getTypeAtLocation(root.decl.name);
+}
+function ancestors(checker, decl) {
+	const out = [];
+	for (let c = decl; c && !out.includes(c); c = baseClass(checker, c)) out.push(c);
+	return out;
+}
+function baseClass(checker, c) {
+	const symbol = c.name && checker.getSymbolAtLocation(c.name);
+	if (!symbol) return void 0;
+	const type = checker.getDeclaredTypeOfSymbol(symbol);
+	const base = checker.getBaseTypes(type)[0]?.getSymbol()?.declarations?.[0];
+	return base && ts.isClassDeclaration(base) ? base : void 0;
+}
+function commonClass(checker, classes) {
+	const [first, ...rest] = classes;
+	const others = rest.map((c) => ancestors(checker, c));
+	return ancestors(checker, first).find((c) => others.every((a) => a.includes(c))) ?? first;
+}
+function returnedExpressions(checker, fn, platform) {
+	if (!fn.body) return [];
+	if (!ts.isBlock(fn.body)) return [fn.body];
+	const out = [];
+	const visit = (n) => {
+		if (ts.isFunctionLike(n)) return;
+		const branch = platform && branchPlatform(checker, n);
+		if (branch && branch !== platform) return;
+		if (ts.isReturnStatement(n) && n.expression) out.push(n.expression);
+		ts.forEachChild(n, visit);
+	};
+	ts.forEachChild(fn.body, visit);
+	return out;
+}
+//#endregion
 //#region ../compiler/src/ui/compose-api.ts
 const KINDS = {
 	double: "Double",
@@ -14723,6 +15762,8 @@ function shownToolkit(node, checker, seen = /* @__PURE__ */ new Set()) {
 function bodyOf(fn, name, checker) {
 	const { title, platform } = TOOLKITS[name];
 	const refused = `a ${title} component returns its body: JSX of ${title}'s views, which the setup's last statement returns`;
+	const native = nativeJsxIn(fn, checker);
+	if (native) fail$2(native, Codes.NativeViewJsx, "JSX of native views is what a component returns: return it, as the last statement of the component");
 	if (fn.body && !ts.isBlock(fn.body)) {
 		if (jsxRoot(fn.body)) return fn.body;
 		bodyFail(fn.body, refused);
@@ -14757,6 +15798,19 @@ function isUiForm(checker, call, name) {
 	const decl = ts.isIdentifier(callee) ? symbolOf$1(checker, callee)?.declarations?.[0] : void 0;
 	return !!decl && ts.isFunctionDeclaration(decl) && decl.name?.text === name && builtinSdkModuleOf(decl.getSourceFile()) === "lucent:ui";
 }
+function nativeJsxIn(fn, checker) {
+	let found;
+	const visit = (n) => {
+		if (found || n !== fn && ts.isFunctionLike(n)) return;
+		if ((ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n)) && nativeTagType(checker, n)) {
+			found = n;
+			return;
+		}
+		ts.forEachChild(n, visit);
+	};
+	if (fn.body) visit(fn.body);
+	return found;
+}
 const isBind = (checker, call) => isUiForm(checker, call, "bind");
 function inSetupCode(node, setup) {
 	for (let n = node.parent; n; n = n.parent) if (ts.isFunctionLike(n)) return n === setup;
@@ -15661,6 +16715,7 @@ const LIBRARY = {
 	},
 	"lucent:android.appContext": NONE,
 	"lucent:android.available": NONE,
+	"lucent:android.errorOf": ALLOCATES,
 	"lucent:ios.available": NONE,
 	"lucent:ui.effect": {
 		allocates: true,
@@ -16531,6 +17586,17 @@ var Collector = class Collector {
 		return !!(decl && this.p.units.byNode.get(decl))?.generator;
 	}
 	jsx(e) {
+		if (!ts.isJsxFragment(e) && nativeTagType(this.checker, e)) {
+			const opening = ts.isJsxElement(e) ? e.openingElement : e;
+			for (const a of opening.attributes.properties) {
+				const value = ts.isJsxAttribute(a) ? a.initializer && ts.isJsxExpression(a.initializer) ? a.initializer.expression : void 0 : a.expression;
+				if (value) this.expr(value);
+			}
+			for (const c of ts.isJsxElement(e) ? e.children : []) if (ts.isJsxExpression(c) && c.expression) this.expr(c.expression);
+			else if (!ts.isJsxText(c)) this.expr(c);
+			this.own("allocates", "yes", e, "makes native views");
+			return this.made(e, "fresh");
+		}
 		if (!jsxToolkitOf(e, this.checker)) return this.unmodeled(e, ts.isJsxFragment(e) ? "a JSX fragment" : "a JSX element");
 		this.own("allocates", "yes", e, "makes a toolkit's body");
 		return this.made(e, "fresh");
@@ -17158,104 +18224,6 @@ function useOf$1(f, decl) {
 	};
 }
 //#endregion
-//#region ../compiler/src/sdk/declarations.ts
-function classOfDecl(decl) {
-	const sdk = sdkModuleOf(decl.getSourceFile());
-	if (!sdk) return void 0;
-	const owner = ts.isClassDeclaration(decl) ? decl : decl.parent;
-	if (!owner || !ts.isClassDeclaration(owner) || !owner.name) return void 0;
-	const cls = findSdkType(sdk.platform, sdk.module, owner.name.text);
-	return cls?.kind === "class" ? {
-		...sdk,
-		cls
-	} : void 0;
-}
-function sdkInterfacesOf(checker, decl) {
-	const out = [];
-	for (const h of decl.heritageClauses ?? []) {
-		if (h.token !== ts.SyntaxKind.ImplementsKeyword) continue;
-		for (const t of h.types) {
-			const d = checker.getTypeAtLocation(t).getSymbol()?.declarations?.find(ts.isClassDeclaration);
-			const ref = d ? classOfDecl(d) : void 0;
-			if (ref?.cls.interface) out.push(ref);
-		}
-	}
-	return out;
-}
-function requirementOf(checker, m) {
-	const cls = m.parent;
-	if (!ts.isClassLike(cls) || !ts.isIdentifier(m.name)) return void 0;
-	for (const protocol of sdkInterfacesOf(checker, cls)) {
-		const method = protocol.cls.methods?.find((x) => !x.static && x.name === m.name.text);
-		if (method) return {
-			protocol,
-			method,
-			main: !!(protocol.cls.mainActor || method.mainActor)
-		};
-	}
-}
-function schemaMethod(ref, decl) {
-	const inherited = inheritedFrom(ref, decl);
-	if (inherited) return {
-		ref: inherited.ref,
-		method: inherited.ref.cls.methods[inherited.index],
-		promise: false
-	};
-	const name = decl.name.text;
-	const index = decl.parent.members.filter((m) => ts.isMethodDeclaration(m) && m.name.text === name).indexOf(decl);
-	return (ref.cls.methods ?? []).flatMap((m) => [...m.name === name ? [{
-		ref,
-		method: m,
-		promise: false
-	}] : [], ...m.async && declaresPromise(ref.cls, m) && (m.async.name ?? m.name) === name ? [{
-		ref,
-		method: m,
-		promise: true
-	}] : []])[index];
-}
-function schemaProperty(ref, decl) {
-	const inherited = inheritedFrom(ref, decl);
-	if (inherited) return {
-		ref: inherited.ref,
-		property: inherited.ref.cls.properties[inherited.index]
-	};
-	const name = decl.name.text;
-	const isStatic = !!ts.getModifiers(decl)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
-	const property = ref.cls.properties?.find((p) => p.name === name && !!p.static === isStatic);
-	return property ? {
-		ref,
-		property
-	} : void 0;
-}
-function inheritedFrom(ref, decl) {
-	const tag = ts.getJSDocTags(decl).find((t) => `@${t.tagName.text}` === INHERITED_TAG);
-	if (!tag) return void 0;
-	const [owner, index] = (ts.getTextOfJSDocComment(tag.comment) ?? "").split(" ");
-	const dot = owner.lastIndexOf(".");
-	const module = owner.slice(0, dot);
-	const cls = findSdkType(ref.platform, module, owner.slice(dot + 1));
-	if (cls?.kind !== "class") throw new Error(`${owner}: no class for an inherited member`);
-	return {
-		ref: {
-			...ref,
-			module,
-			cls
-		},
-		index: Number(index)
-	};
-}
-function schemaConstructor(ref, decl) {
-	return ref.cls.constructors[decl.parent.members.filter(ts.isConstructorDeclaration).indexOf(decl)];
-}
-function promiseForm(m) {
-	const { throws: _, ...rest } = m;
-	return {
-		...rest,
-		params: m.params.slice(0, -1),
-		returns: m.async.returns
-	};
-}
-//#endregion
 //#region ../compiler/src/analysis/native.ts
 const NO_NATIVE = {
 	use: () => void 0,
@@ -17280,6 +18248,7 @@ const COPIED$1 = /* @__PURE__ */ new Set([
 	"copy-array",
 	"copy-record",
 	"copy-set",
+	"copy-tuple",
 	"copy-date"
 ]);
 function callbackOf$1(plan) {
@@ -17376,7 +18345,7 @@ function classMemberPlan(ref, decl, role) {
 		return memberPlan(owner.platform, owner.module, owner.cls, promise ? promiseForm(method) : method, "call");
 	}
 	if (ts.isConstructorDeclaration(decl)) return memberPlan(ref.platform, ref.module, ref.cls, schemaConstructor(ref, decl), "new");
-	if (!ts.isPropertyDeclaration(decl) || !ts.isIdentifier(decl.name)) return void 0;
+	if (!isSdkPropertyDecl(decl) || !ts.isIdentifier(decl.name)) return void 0;
 	const found = schemaProperty(ref, decl);
 	if (!found) return void 0;
 	const { ref: owner, property } = found;
@@ -20044,10 +21013,12 @@ var Lowerer = class Lowerer {
 		if (node.flags & ts.NodeFlags.OptionalChain) this.unsupported(node, "optional chains");
 		const { operands, args } = this.operands();
 		const place = host.place(node, operands);
+		const assign = place.assign;
 		return {
 			type: place.type,
 			read: () => this.planOf(place.get, args, spanOf(node)),
-			write: (v, span) => void this.planOf(place.set(v), [...args, v], span)
+			write: (v, span) => void this.planOf(place.set(v), [...args, v], span),
+			...assign ? { assign: (v, span) => void this.planOf(assign(v, this.b.typeOf(v)), [...args, v], span) } : {}
 		};
 	}
 	asserted(node) {
@@ -20703,6 +21674,11 @@ const BINARY_FORMS = {
 			return value;
 		}
 		const target = lw.target(n.left);
+		if (target.assign) {
+			const value = lw.expr(n.right);
+			target.assign(value, spanOf(n));
+			return value;
+		}
 		const value = lw.expr(n.right, target.type);
 		target.write(lw.coerce(value, target.type, n.right), spanOf(n));
 		return value;
@@ -22168,6 +23144,7 @@ var Ctx = class {
 	platform;
 	frameworks = /* @__PURE__ */ new Set();
 	pods = /* @__PURE__ */ new Set();
+	swiftPackages = /* @__PURE__ */ new Set();
 	javaClasses = /* @__PURE__ */ new Set();
 	androidPermissions = /* @__PURE__ */ new Set();
 	nativeUnits = /* @__PURE__ */ new Map();
@@ -22771,6 +23748,38 @@ function suspending(p, module) {
 function anyFor(name, bounds) {
 	return bounds?.[name] === "non-null" ? type$3("Any") : nullable$1(type$3("Any"));
 }
+function boundType(ref) {
+	const named = type$3(ref.name, ...(ref.args ?? []).map((a) => a === "*" ? star : boundType(a)));
+	return ref.nullable ? nullable$1(named) : named;
+}
+function declaredTypeParams(use) {
+	const classFacts = use.cls.kotlin;
+	const memberFacts = use.member.kotlin;
+	const classParams = use.cls.typeParams ?? [];
+	const memberParams = "typeParams" in use.member ? use.member.typeParams ?? [] : [];
+	const other = (f) => Object.keys(f?.upperBounds ?? {}).length > 0;
+	if (!other(classFacts) && !other(memberFacts)) return {
+		names: [],
+		bounds: {}
+	};
+	const fromClass = use.instance || use.role === "new" ? classParams : [];
+	const clash = memberParams.find((n) => fromClass.includes(n));
+	if (clash) fail$2(use.node, Codes.UnsupportedCall, `${use.what}: its type parameter ${clash} shadows its class's, which a shim cannot declare twice`);
+	const bounds = {};
+	const bind = (names, f) => {
+		for (const n of names) {
+			const upper = f?.upperBounds?.[n];
+			if (upper) bounds[n] = upper.map(boundType);
+			else if (f?.bounds?.[n] === "non-null") bounds[n] = [type$3("Any")];
+		}
+	};
+	bind(fromClass, classFacts);
+	bind(memberParams, memberFacts);
+	return {
+		names: [...fromClass, ...memberParams],
+		bounds
+	};
+}
 function boundary(t) {
 	const prim = primOf(t);
 	return prim ? {
@@ -22796,6 +23805,7 @@ function kotlinType$1(use, t) {
 				return of ? type$3(`kotlin.${of.kotlin}Array`) : type$3("kotlin.Array", kotlinType$1(use, t.of));
 			}
 			case "tparam": {
+				if (declaredTypeParams(use).names.includes(t.name)) return type$3(t.name);
 				const own = "typeParams" in use.member && use.member.typeParams?.includes(t.name);
 				return anyFor(t.name, own ? use.member.kotlin?.bounds : use.cls.kotlin?.bounds);
 			}
@@ -22831,7 +23841,8 @@ function kotlinShim(ctx, use) {
 		memberName,
 		use.given.map((g, i) => g ? use.wrapped[i] ? "f" : 1 : 0).join("")
 	].join("|");
-	const name = `${use.cls.name}_${use.role === "get" ? `get_${memberName}` : memberName}_${hashOf(key)}`;
+	const accessor = use.role === "get" || use.role === "set" ? `${use.role}_` : "";
+	const name = `${use.cls.name}_${accessor}${memberName}_${hashOf(key)}`;
 	const shims = ctx.kotlinShims.get(use.module) ?? /* @__PURE__ */ new Map();
 	ctx.kotlinShims.set(use.module, shims);
 	const made = shims.get(name);
@@ -22850,6 +23861,7 @@ function kotlinShim(ctx, use) {
 	const receiverType = (extension ? params[0] : void 0)?.type;
 	if (use.instance) take("receiver", "receiver");
 	else if (receiverType) take("receiver", primOf(receiverType) ? receiverType : "receiver");
+	if (use.role === "set" && "type" in use.member) take("value", use.member.type);
 	const sourceParams = extension ? params.slice(1) : params;
 	const given = extension ? use.given.slice(1) : use.given;
 	const wrapped = extension ? use.wrapped.slice(1) : use.wrapped;
@@ -22864,8 +23876,10 @@ function kotlinShim(ctx, use) {
 			value: runs ? suspendingLambda(a, runs) : primOf(p.type) ? name$2(a) : call$3(name$2("cast"), [{ value: name$2(a) }])
 		});
 	});
-	const classArgs = (use.cls.typeParams ?? []).map((n) => anyFor(n, use.cls.kotlin?.bounds));
-	const memberArgs = ("typeParams" in use.member ? use.member.typeParams ?? [] : []).map((n) => anyFor(n, use.member.kotlin?.bounds));
+	const declared = declaredTypeParams(use);
+	const typeArg = (n, bounds) => declared.names.includes(n) ? type$3(n) : anyFor(n, bounds);
+	const classArgs = (use.cls.typeParams ?? []).map((n) => typeArg(n, use.cls.kotlin?.bounds));
+	const memberArgs = ("typeParams" in use.member ? use.member.typeParams ?? [] : []).map((n) => typeArg(n, use.member.kotlin?.bounds));
 	const typeArgs = (list) => list.length ? list : void 0;
 	const cast = (t) => call$3(name$2("cast"), [{ value: name$2("receiver") }], void 0, [t]);
 	const pkg = use.module;
@@ -22880,7 +23894,7 @@ function kotlinShim(ctx, use) {
 		const n = identifier(use, memberName);
 		if (extension) imports.push(`${pkg}.${n}`);
 		const reached = target ? member$5(target, n) : qualified(`${topLevel ? pkg : kotlinName(use.cls.native)}.${n}`);
-		return use.role === "get" ? reached : call$3(reached, args, void 0, typeArgs(memberArgs));
+		return use.role === "get" || use.role === "set" ? reached : call$3(reached, args, void 0, typeArgs(memberArgs));
 	})();
 	let body;
 	let ret;
@@ -22891,6 +23905,10 @@ function kotlinShim(ctx, use) {
 		ret = type$3("AutoCloseable");
 		retDescriptor = "Ljava/lang/AutoCloseable;";
 		body = [ret$1(call$3(name$2("start"), [{ value: name$2("done") }], lambda$1([], [exprStmt$2(call)])))];
+	} else if (use.role === "set") {
+		const value = "type" in use.member && primOf(use.member.type);
+		retDescriptor = "V";
+		body = [assign$2(call, value ? name$2("value") : call$3(name$2("cast"), [{ value: name$2("value") }]))];
 	} else if (isVoid$1(use.returns)) {
 		retDescriptor = "V";
 		body = [exprStmt$2(call)];
@@ -22908,6 +23926,10 @@ function kotlinShim(ctx, use) {
 			k: "fun",
 			annotations: ["JvmStatic"],
 			modifiers: [],
+			...declared.names.length ? {
+				typeParams: declared.names,
+				bounds: declared.bounds
+			} : {},
 			name,
 			params: shimParams,
 			...ret ? { ret } : {},
@@ -23621,7 +24643,7 @@ function toLucent(ctx, vt, lt, r) {
 		case "string": return call$5(views("lucentString"), [r]);
 		case "enum": return call$5(views("lucentString"), [dot(r, "value")]);
 		case "array": {
-			const e = element(lt);
+			const e = element$1(lt);
 			return call$5(views("lucentArray"), [r, each(toLucent(ctx, vt.element, e, value))], [ctx.reg.cppType(e)]);
 		}
 		case "nullable": {
@@ -23657,7 +24679,7 @@ function assignRepr(ctx, target, vt, lt, src) {
 		case "array": return [exprStmt$4(call$5(views("assignArray"), [
 			target,
 			src,
-			each((t, e) => assignRepr(ctx, t, vt.element, element(lt), e))
+			each((t, e) => assignRepr(ctx, t, vt.element, element$1(lt), e))
 		]))];
 		case "nullable": return [exprStmt$4(call$5(views("assignOpt"), [
 			target,
@@ -23689,7 +24711,7 @@ function unwrapped(lt) {
 	if (lt.k !== "opt") throw new Error(`expected an optional type (got ${lt.k})`);
 	return lt.inner;
 }
-function element(lt) {
+function element$1(lt) {
 	if (lt.k !== "array") throw new Error(`expected an array type (got ${lt.k})`);
 	return lt.e;
 }
@@ -24742,6 +25764,153 @@ const composeEmitter = {
 	}
 };
 //#endregion
+//#region ../compiler/src/emit/native-jsx.ts
+function nativeJsx(em, node) {
+	const setup = setupOf(em.ctx, node);
+	if (!setup || !returnedBy(node, setup.fn)) fail$2(node, Codes.NativeViewJsx, "JSX of native views is what a component returns: return it, as the last statement of the component");
+	const made = {
+		statements: [],
+		cleanup: [],
+		captures: []
+	};
+	const root = element(em, node, made);
+	made.statements.push(exprStmt$4(call$5(arrow$1(call$5("lucent::ui::mainGraph"), "onCleanup"), [lambda$2(made.captures, [], made.cleanup)])));
+	return {
+		c: statementExpr(made.statements, id(root)),
+		t: setup.root
+	};
+}
+const discarded = (c) => exprStmt$4(c.k === "call" ? c : cast$3("c", voidType, c));
+function returnedBy(node, fn) {
+	let at = node;
+	while (ts.isParenthesizedExpression(at.parent)) at = at.parent;
+	const body = fn.body;
+	const last = body && ts.isBlock(body) ? body.statements.at(-1) : void 0;
+	return body === at || !!last && ts.isReturnStatement(last) && last.expression === at;
+}
+function refuseCopies(em, fn, value) {
+	const props = fn.parameters[0] && em.checker.getSymbolAtLocation(fn.parameters[0].name);
+	const body = fn.body && ts.isBlock(fn.body) ? fn.body : void 0;
+	if (!props || !body) return;
+	const visit = (n) => {
+		if (ts.isFunctionLike(n)) return;
+		const decl = (ts.isIdentifier(n) ? em.checker.getSymbolAtLocation(n) : void 0)?.valueDeclaration;
+		const statement = decl?.parent?.parent;
+		let read = decl && ts.isVariableDeclaration(decl) ? decl.initializer : void 0;
+		while (read && ts.isParenthesizedExpression(read)) read = read.expression;
+		let root = read;
+		while (root && ts.isPropertyAccessExpression(root)) root = root.expression;
+		if (read && read !== root && root && ts.isIdentifier(root) && em.checker.getSymbolAtLocation(root) === props && statement && ts.isVariableStatement(statement) && statement.parent === body) fail$2(n, Codes.NativeViewJsx, `\`${n.getText()}\` is ${read.getText()} as setup first read it: the attribute would never change`, `read ${read.getText()} in the attribute, which keeps it up to date`);
+		ts.forEachChild(n, visit);
+	};
+	visit(value);
+}
+function element(em, node, made) {
+	const setup = setupOf(em.ctx, node);
+	let jsx = node;
+	while (ts.isParenthesizedExpression(jsx)) jsx = jsx.expression;
+	if (!ts.isJsxElement(jsx) && !ts.isJsxSelfClosingElement(jsx)) fail$2(node, Codes.NativeViewJsx, "a native view's children are elements of native views");
+	const opening = ts.isJsxElement(jsx) ? jsx.openingElement : jsx;
+	const tag = opening.tagName;
+	const ref = sdkTagClass(em, tag);
+	if (!ref) fail$2(tag, Codes.NativeViewJsx, `<${tag.getText()}> is no SDK view class: a native view's JSX is UIKit's or Android's views`);
+	const at = tag;
+	const schema = findSdkModule(ref.platform, ref.module);
+	if (!schema) throw new Error(`${ref.module}: no schema for a class it declares`);
+	const rules = viewTag(ref.cls, schema, (m) => findSdkModule(ref.platform, m));
+	const owned = (o) => ({
+		platform: ref.platform,
+		module: o.schema.module,
+		cls: o.cls
+	});
+	const lt = em.reg.lower(nativeTagType(em.checker, node), node);
+	const view = em.ctx.fresh(`view_${ref.cls.name}`);
+	const attributes = opening.attributes.properties;
+	for (const a of attributes) if (!ts.isJsxAttribute(a)) fail$2(a, Codes.NativeViewJsx, "a native view's attributes are written one by one, not spread");
+	const named = (name) => attributes.find((a) => ts.isJsxAttribute(a) && a.name.getText() === name);
+	const valueOf = (a) => a.initializer && ts.isJsxExpression(a.initializer) ? a.initializer.expression : a.initializer;
+	const create = named("create");
+	const createdBy = create && valueOf(create);
+	if (createdBy) {
+		const f = em.ctx.fresh("create");
+		made.statements.push(varDecl(auto$1, f, em.expr(createdBy).c), varDecl(auto$1, view, call$5(id(f), [])));
+	} else {
+		if (rules.construction.kind === "create") fail$2(tag, Codes.NativeViewJsx, rules.construction.reason);
+		made.statements.push(varDecl(auto$1, view, viewNew(em, at, ref, rules.construction, lt).c));
+	}
+	const self = {
+		c: id(view),
+		t: lt
+	};
+	made.captures.push(view);
+	for (const a of attributes) {
+		const name = a.name.getText();
+		if (name === "create") continue;
+		const value = valueOf(a);
+		const prop = rules.props.get(name);
+		const event = rules.events.get(name);
+		if (event) {
+			if (!value) fail$2(a, Codes.NativeViewJsx, `${name} takes a function`);
+			const owner = owned(event.owner);
+			const handler = em.expr(value);
+			if (event.event.kind === "listener") {
+				const listened = listenerEvent(em, value, owner, event.event.setter, self, handler);
+				made.statements.push(exprStmt$4(listened.add));
+				made.cleanup.push(exprStmt$4(listened.remove));
+			} else {
+				const action = em.ctx.fresh("action");
+				const control = controlEvent(em, value, owner, ref, event.event.register, event.event.value, self, handler);
+				made.statements.push(varDecl(auto$1, action, control.add));
+				made.cleanup.push(exprStmt$4(control.remove(id(action))));
+				made.captures.push(action);
+			}
+			continue;
+		}
+		if (!prop) fail$2(a, Codes.NativeViewJsx, `<${ref.cls.name}> has no ${name}: what its declarations give is a writable property, a setter, an event, or children`);
+		const owner = owned(prop.owner);
+		const type = em.lt(a.name);
+		const set = (v) => prop.prop.kind === "property" ? propertySetter(em, value ?? at, owner, prop.prop.member, self, type)(v.c) : setterCall(em, value ?? at, owner, prop.prop.overloads, self, v);
+		if (!value) {
+			made.statements.push(discarded(set({
+				c: id("true"),
+				t: T.boolean
+			})));
+			continue;
+		}
+		refuseCopies(em, setup.fn, value);
+		const property = prop.prop.kind === "property";
+		const get = em.thunk(value, {
+			site: value,
+			...property ? { type } : {}
+		});
+		const got = !property && get.t.k === "fn" ? get.t.ret : type;
+		const keep = lambda$2([view, {
+			name: "lucent_get",
+			init: get.c
+		}], [], [varDecl(auto$1, "lucent_value", call$5(id("lucent_get"))), discarded(set({
+			c: id("lucent_value"),
+			t: got
+		}))], { mutable: true });
+		made.statements.push(exprStmt$4(call$5("lucent::ui::effect", [
+			call$5("lucent::ui::mainGraph"),
+			enterMount(em, value, keep),
+			str$5(site(value))
+		])));
+	}
+	const children = ts.isJsxElement(jsx) ? jsx.children.filter((c) => !(ts.isJsxText(c) && c.containsOnlyTriviaWhiteSpaces)) : [];
+	if (children.length && !rules.children) fail$2(children[0], Codes.NativeViewJsx, `<${ref.cls.name}> takes no children: its class declares no method inserting a view at an index`);
+	children.forEach((c, index) => {
+		if (!ts.isJsxElement(c) && !ts.isJsxSelfClosingElement(c)) fail$2(c, Codes.NativeViewJsx, "a native view's children are elements of native views");
+		const child = element(em, c, made);
+		const { rule, owner } = rules.children;
+		made.statements.push(exprStmt$4(insertChild(em, c, owned(owner), rule.insert, self, {
+			c: id(child),
+			t: lt
+		}, index)));
+	});
+	return view;
+}
+//#endregion
 //#region ../compiler/src/ui/source-members.ts
 const indexes = /* @__PURE__ */ new WeakMap();
 function indexOf$1(schema) {
@@ -25744,7 +26913,7 @@ function writable(node, found) {
 	const refused = unsupportedReason(found.plan);
 	if (refused) bodyFail(node, `\`${found.display}\` cannot be written in a SwiftUI body yet: ${refused}`);
 	const since = found.plan.availability?.since;
-	if (typeof since === "string" && compareVersions(since, "15.1") > 0) bodyFail(node, `\`${found.display}\` needs iOS ${since} (apps run from iOS ${MIN_IOS}): a SwiftUI body writes what every supported iOS has, for now`);
+	if (typeof since === "string" && compareVersions(since, oldestIos()) > 0) bodyFail(node, `\`${found.display}\` needs iOS ${since} (apps run from iOS ${oldestIos()}): a SwiftUI body writes what every supported iOS has, for now`);
 }
 function isNothing(e) {
 	return e.kind === ts.SyntaxKind.NullKeyword || e.kind === ts.SyntaxKind.FalseKeyword || ts.isIdentifier(e) && e.text === "undefined";
@@ -26345,6 +27514,7 @@ function toolkitMember(em, node) {
 }
 const BODY_PLACE = "the body a component returns";
 function toolkitJsx(em, node) {
+	if (nativeTagType(em.checker, node)) return nativeJsx(em, node);
 	const toolkit = jsxToolkitOf(node, em.checker);
 	const setup = setupOf(em.ctx, node);
 	if (!toolkit) throw new Error("JSX in a file of no toolkit (the program refuses it)");
@@ -26870,10 +28040,10 @@ function mountUnit(ctx, s) {
 	};
 	const ns = `lucent_app::${s.module.ns}`;
 	const where = str$5(`${path.basename(c.source.file)}:${c.source.line}`);
-	const id$10 = str$5(c.id);
+	const id$14 = str$5(c.id);
 	const view = (e, what) => exprStmt$4(call$5("lucent::ui::reportViewError", [
 		e,
-		id$10,
+		id$14,
 		str$5(what),
 		where
 	]));
@@ -27660,6 +28830,7 @@ function bareSwiftType(t) {
 		case "id": return type$2("Any");
 		case "array": return array$1(swiftType(t.of));
 		case "record": return dictionary(type$2("String"), swiftType(t.of));
+		case "fn": return blockFunction(t.params.map(swiftType), t.ret.k === "prim" && t.ret.name === "void" ? type$2("Void") : swiftType(t.ret));
 		case "ref": {
 			const info = sdkTypeInfo("ios", t.module, t.name);
 			if (info?.kind === "struct") return type$2(info.native);
@@ -27704,6 +28875,14 @@ function fromObject(t, o) {
 		case "record":
 			if (bridges(t.of)) return cast$4(swiftType(t));
 			return each(cast$4(dictionary(type$2("String"), type$2("AnyObject"))), "mapValues", fromObject(t.of, n("$0")));
+		case "fn": return call$2(n("unsafeBitCast"), [{ value: o }, {
+			label: "to",
+			value: n(`(${printType$1(swiftType(t))}).self`)
+		}]);
+		case "tuple": {
+			const items = cast$4(array$1(type$2("AnyObject")));
+			return tupleLiteral(t.of.map((x, i) => fromObject(x, index(items, num$3(i)))));
+		}
 		case "ref": {
 			const e = swiftEnum(t);
 			if (e) return index(casesOf(e), member$4(cast$4(type$2("NSNumber")), "intValue"));
@@ -27732,6 +28911,11 @@ function toObject(t, v) {
 		case "id": return as(v, "AnyObject");
 		case "array": return as(bridges(t.of) ? v : each(v, "map", toObject(t.of, n("$0"))), "NSArray");
 		case "record": return as(bridges(t.of) ? v : each(v, "mapValues", toObject(t.of, n("$0"))), "NSDictionary");
+		case "fn": return call$2(n("unsafeBitCast"), [{ value: cast(v, "as", swiftType(t)) }, {
+			label: "to",
+			value: n("AnyObject.self")
+		}]);
+		case "tuple": return as(arrayLiteral(t.of.map((x, i) => as(toObject(x, member$4(v, String(i))), "AnyObject"))), "NSArray");
 		case "ref": {
 			const e = swiftEnum(t);
 			if (e) return call$2(n("NSNumber"), [{
@@ -28179,7 +29363,10 @@ const REFUSAL_CODES = {
 function requirePlan(node, of, member, role, declared = member) {
 	const plan = memberPlan(of.platform, of.module, of.cls, member, role);
 	const why = explainRefusal(plan);
-	if (why) fail$2(node, plan.refused ? REFUSAL_CODES[plan.refused.rule] ?? Codes.UnsupportedCall : Codes.UnsupportedType, why);
+	if (why) {
+		if (plan.refused) fail$2(node, REFUSAL_CODES[plan.refused.rule] ?? Codes.UnsupportedCall, why);
+		fail$2(node, Codes.UnsupportedType, why, WRAP_UNBOUND[of.platform]);
+	}
 	noteSdkUse(of.platform, of.module, of.cls, declared, plan);
 	return plan;
 }
@@ -28427,6 +29614,10 @@ function toObjcExpr(t, c, owned, what = "a value") {
 			return t.cf ? bridgeTo("CFArrayRef", arr) : arr;
 		}
 		case "set": return objc("toNSSet", eachElement(t.of));
+		case "tuple": {
+			const v = id("t_");
+			return statementExpr([varDecl(auto$1, "t_", c)], call$5("lucent::objc::toNSArrayOf", t.of.map((x, i) => boxed(x, call$5("std::get", [v], [num$5(i)])))));
+		}
 		case "record": {
 			const dict = objc("toNSDictionary", eachElement(t.of));
 			return t.cf ? bridgeTo("CFDictionaryRef", dict) : dict;
@@ -28480,7 +29671,7 @@ function toObjc(em, arg, t, use, owned = false) {
 	if (t.k === "id" || t.k === "tparam") return toObjcExpr(t, em.expr(arg).c, owned);
 	if (t.k === "out") return outArg(em, arg, t, owned);
 	const what = argumentWhat(em, arg);
-	if (sdkStruct(t)) {
+	if (sdkStruct(t) || t.k === "tuple") {
 		const declared = em.checker.getContextualType(arg);
 		const lt = declared ? em.reg.lower(declared, arg) : em.lt(arg);
 		return toObjcExpr(t, em.exprAs(arg, lt), owned, what);
@@ -28627,6 +29818,18 @@ function fromObjc(em, code, t, lt, what, owned = false) {
 			c: objc("fromNSError", code, w),
 			t: lt
 		};
+		case "tuple": {
+			const tuple = elem(lt);
+			if (tuple.k !== "tuple") throw new Error(`${what}: a tuple read as ${tuple.k}`);
+			const items = t.of.map((x, i) => {
+				const read = lambda$2(["&"], [param$5(type$5("id"), "e_")], [ret$3(fromObjcItem(em, x, tuple.es[i], what))], { ret: em.reg.cppType(tuple.es[i]) });
+				return call$5(read, [send$1(id("a_"), "objectAtIndex:", [num$5(i)])]);
+			});
+			return {
+				c: statementExpr([varDecl(objcPointer("NSArray"), "a_", cast$3("c", objcPointer("NSArray"), code))], construct(em.reg.cppType(tuple), items)),
+				t: tuple
+			};
+		}
 		default: throw new Error(`${what}: an Objective-C ${t.k} value its plan refuses`);
 	}
 }
@@ -28799,7 +30002,8 @@ function jniArgument(em, ref, arg, t) {
 				t: typed
 			};
 		}
-		case "tparam": return em.expr(arg);
+		case "tparam":
+		case "fn": return em.expr(arg);
 		default: throw new Error(`${t.k} values, which plans refuse over JNI`);
 	}
 }
@@ -28836,8 +30040,10 @@ function jniOf(em, arg, t, value) {
 		}
 		case "ref":
 			if (value.t.k === "fn") return javaProxy(em, arg, value, t);
+			if (eitherMembers(value.t)) return jniEither(em, arg, t, value);
 			return jni("unwrap", value.c);
 		case "tparam": return toJavaObject(arg, value);
+		case "fn": return toKotlinFunction(em, arg, t, value);
 		default: throw new Error(`${t.k} values, which plans refuse over JNI`);
 	}
 }
@@ -28912,38 +30118,84 @@ function javaProxy(em, arg, f, t) {
 function proxyEntry(em, node, module, owner, m, fn, capture, call) {
 	const params = m.params.map((p) => parseSdkType(p.type, module, m.typeParams ?? []));
 	const n = Math.min(fn.params.length, params.length);
-	const what = `${owner}.${m.name}`;
 	const cls = findSdkType("android", module, owner);
-	if (cls?.kind !== "class") throw new Error(`${what}: no class`);
+	if (cls?.kind !== "class") throw new Error(`${owner}.${m.name}: no class`);
 	const plan = requirePlan(node, {
 		platform: "android",
 		module,
 		cls
 	}, m, "implement");
 	requireTaken(node, plan, plan.inputs, n);
-	const args = proxyArguments(em, node, params.slice(0, n), fn, what);
+	const descriptor = m.descriptor ?? jniDescriptor(m.params.map((p) => p.type), m.returns, m.typeParams);
+	const ret = parseSdkType(m.returns, module, m.typeParams ?? []);
+	const what = `${owner}.${m.name}`;
+	const suspend = !!m.kotlin?.suspend;
+	const slots = descriptorSlots(descriptor);
+	const result = unboxedSlot(ret, suspend ? void 0 : slots.ret);
+	const valueLt = suspend && fn.ret.k === "promise" ? fn.ret.inner : fn.ret;
+	const box = (r) => result ? jni("unboxValueClass", env, str$5(result.native), str$5(result.underlying), jni("unwrap", r)) : suspend && ret.k === "prim" && ret.name === "void" ? jni("unit", env) : boxJava(em, node, ret, r, what, valueLt);
+	return proxyMethod(em, node, {
+		key: `${m.java ?? m.name}${descriptor.slice(0, descriptor.indexOf(")") + 1)}`,
+		params: params.slice(0, n),
+		unboxed: params.slice(0, n).map((p, i) => unboxedSlot(p, slots.params[i])),
+		box,
+		queued: plan.delivery === "queued",
+		...suspend ? { continuation: params.length } : {},
+		what,
+		fn,
+		capture,
+		call
+	});
+}
+function descriptorSlots(descriptor) {
+	const slots = descriptor.match(/\[*(?:[ZBCSIJFDV]|L[^;]+;)/g) ?? [];
+	return {
+		params: slots.slice(0, -1),
+		ret: slots.at(-1) ?? "V"
+	};
+}
+function unboxedSlot(t, slot) {
+	if (t.k !== "ref" || !slot) return void 0;
+	const cls = findSdkType("android", t.module, t.name);
+	if (cls?.kind !== "class" || !cls.kotlin?.value) return void 0;
+	return slot === `L${cls.native};` ? void 0 : {
+		native: cls.native,
+		underlying: slot
+	};
+}
+function proxyMethod(em, node, m) {
+	const args = proxyArguments(em, node, m.params, m.fn, m.what, m.unboxed);
 	const names = args.map((_, i) => `a${i}_`);
 	const convert = args.map((a, i) => varDecl(auto$1, names[i], a));
-	const ret = parseSdkType(m.returns, module, m.typeParams ?? []);
-	const holder = typeof capture === "string" ? capture : capture.name;
-	const made = call(names.map(id));
+	const holder = typeof m.capture === "string" ? m.capture : m.capture.name;
+	const made = m.call(names.map(id));
 	const jobject = type$5("jobject");
 	const entry = callbackEntry(em, node);
-	const body = plan.delivery === "queued" ? [
+	const resumed = (k) => {
+		const resume = id("resume_");
+		const boxValue = lambda$2([], [param$5(pointer(type$5("JNIEnv")), "env"), param$5(reference(constType(auto$1)), "v_")], [ret$3(m.box(id("v_")))], { ret: jobject });
+		const run = lambda$2([
+			holder,
+			...names,
+			"resume_"
+		], [], [exprStmt$4(jni("resumeWithResult", resume, lambda$2(["&"], [], [ret$3(made)]), boxValue))]);
+		const start = lambda$2([holder, ...names], [param$5(type$5("lucent::jni::Resume"), "resume_")], [exprStmt$4(entry.later(run))]);
+		return [...convert, ret$3(jni("suspendedCall", env, jni("arg", env, id("args_"), num$5(k)), start))];
+	};
+	const body = m.continuation !== void 0 ? resumed(m.continuation) : m.queued ? [
 		...convert,
 		exprStmt$4(entry.later(lambda$2([holder, ...names], [], [exprStmt$4(cast$3("c", voidType, made))]))),
 		ret$3(nullptr)
-	] : [...convert, ret$3(entry.now(lambda$2(["&"], [], [varDecl(auto$1, "r_", made), ret$3(boxJava(node, ret, id("r_"), what, fn.ret))], { ret: jobject })))];
-	const descriptor = m.descriptor ?? jniDescriptor(m.params.map((p) => p.type), m.returns, m.typeParams);
-	const key = `${m.java ?? m.name}${descriptor.slice(0, descriptor.indexOf(")") + 1)}`;
-	const method = lambda$2([capture], [param$5(pointer(type$5("JNIEnv")), "env"), param$5(type$5("jobjectArray"), "args_")], body, { ret: jobject });
-	return initList([str$5(key), method]);
+	] : [...convert, ret$3(entry.now(lambda$2(["&"], [], [varDecl(auto$1, "r_", made), ret$3(m.box(id("r_")))], { ret: jobject })))];
+	const method = lambda$2([m.capture], [param$5(pointer(type$5("JNIEnv")), "env"), param$5(type$5("jobjectArray"), "args_")], body, { ret: jobject });
+	return initList([str$5(m.key), method]);
 }
-function proxyArguments(em, node, params, fn, what) {
+function proxyArguments(em, node, params, fn, what, unboxed = []) {
 	return params.map((p, i) => {
-		const a = jni("arg", env, id("args_"), num$5(i));
-		if (p.k === "prim") return unboxedPrim(p, a);
-		return fromJni(em, a, p, fn.params[i], what, node).c;
+		const arg = jni("arg", env, id("args_"), num$5(i));
+		if (p.k === "prim") return unboxedPrim(p, arg);
+		const v = unboxed[i];
+		return fromJni(em, v ? jni("boxValueClass", env, str$5(v.native), str$5(v.underlying), arg) : arg, p, fn.params[i], what, node).c;
 	});
 }
 function kotlinFunction(em, arg, f, runs, what, site) {
@@ -28957,7 +30209,7 @@ function kotlinFunction(em, arg, f, runs, what, site) {
 	const ret = runs.returns;
 	const result = () => {
 		const r = id("r_");
-		if (ret.k === "tparam") return boxJava(arg, ret, r, what, fn.ret);
+		if (ret.k === "tparam") return boxJava(em, arg, ret, r, what, fn.ret);
 		if (ret.k === "ref") return envCall("NewLocalRef", toJavaObjectOf(em, ret, r, fn.ret, what));
 		return toJavaObjectOf(em, ret, r, fn.ret, what);
 	};
@@ -28967,6 +30219,94 @@ function kotlinFunction(em, arg, f, runs, what, site) {
 	const key = `invoke(${"Ljava/lang/Object;".repeat(arity)})`;
 	return statementExpr([varDecl(auto$1, "f_", f.c)], jni("proxyFor", env, javaClass(em, `kotlin/jvm/functions/Function${arity}`), call$5(dot(id("f_"), "identity")), initList([initList([str$5(key), method])]), str$5(site)));
 }
+function eitherMembers(t) {
+	const inner = stripOpt(t);
+	return inner.k === "union" && inner.ms.some((m) => m.k === "fn") ? inner.ms : void 0;
+}
+function jniEither(em, arg, t, value) {
+	const jobject = type$5("jobject");
+	const present = (v) => {
+		const u = id("u_");
+		const each = eitherMembers(v.t).map((m, i) => {
+			const got = {
+				c: call$5("std::get", [u], [num$5(i)]),
+				t: m
+			};
+			return {
+				test: binary$2(call$5(dot(u, "index")), "==", num$5(i)),
+				c: staticCast(jobject, m.k === "fn" ? javaProxy(em, arg, got, t) : jni("unwrap", got.c))
+			};
+		});
+		const chain = each.slice(0, -1).reduceRight((rest, e) => conditional$1(e.test, e.c, rest), each.at(-1).c);
+		return statementExpr([varDecl(auto$1, "u_", v.c)], chain);
+	};
+	return value.t.k === "opt" ? whenPresent(value, present) : present(value);
+}
+function whenPresent(value, present) {
+	if (value.t.k !== "opt") throw new Error(`an optional value that is a ${value.t.k}`);
+	const jobject = type$5("jobject");
+	const o = id("o_");
+	return statementExpr([varDecl(auto$1, "o_", value.c)], conditional$1(call$5(dot(o, "has")), staticCast(jobject, present({
+		c: call$5(dot(o, "get")),
+		t: value.t.inner
+	})), staticCast(jobject, nullptr)));
+}
+function toKotlinFunction(em, arg, t, value) {
+	if (value.t.k === "null" || value.t.k === "undefined") return nullptr;
+	if (value.t.k === "opt") return whenPresent(value, (v) => toKotlinFunction(em, arg, t, v));
+	const fn = value.t;
+	if (fn.k !== "fn") fail$2(arg, Codes.UnsupportedType, "pass a function");
+	const what = argumentWhat(em, arg);
+	const plan = kotlinFunctionConversion(t);
+	if (plan.op !== "callback") throw new Error(`${what}: a Kotlin function its plan refuses`);
+	const n = Math.min(fn.params.length, t.params.length);
+	requireTaken(arg, { display: what }, plan.of.slice(0, -1), n);
+	const ret = t.ret;
+	const box = (r) => {
+		if (ret.k === "tparam") return boxJava(em, arg, ret, r, what, fn.ret);
+		if (ret.k === "ref") return envCall("NewLocalRef", toJavaObjectOf(em, ret, r, fn.ret, what));
+		return toJavaObjectOf(em, ret, r, fn.ret, what);
+	};
+	const entry = proxyMethod(em, arg, {
+		key: `invoke(${"Ljava/lang/Object;".repeat(t.params.length)})`,
+		params: t.params.slice(0, n),
+		box,
+		queued: plan.delivery === "queued",
+		what,
+		fn,
+		capture: "f_",
+		call: (a) => call$5(id("f_"), a)
+	});
+	return statementExpr([varDecl(auto$1, "f_", value.c)], jni("proxyFor", env, javaClass(em, `kotlin/jvm/functions/Function${t.params.length}`), call$5(dot(id("f_"), "identity")), initList([entry])));
+}
+function fromKotlinFunction(em, code, t, lt, what, node) {
+	const fn = stripOpt(lt);
+	if (fn.k !== "fn") throw new Error(`${what}: a Kotlin function read as ${fn.k}`);
+	const arity = t.params.length;
+	const params = fn.params.map((p, i) => param$5(em.reg.cppType(p), `v${i}_`));
+	const args = t.params.map((p, i) => i < params.length ? toJavaObjectOf(em, p, id(`v${i}_`), fn.params[i], what) : nullptr);
+	const isVoid = t.ret.k === "prim" && t.ret.name === "void";
+	const r = id("r_");
+	const result = isVoid ? void 0 : t.ret.k === "prim" ? unboxedPrim(t.ret, r) : fromJni(em, r, t.ret, fn.ret, `${what}'s result`, node).c;
+	const call = envCall("CallObjectMethod", jni("unwrap", id("f_")), id("id_"), ...args);
+	const body = [
+		varDecl(pointer(type$5("JNIEnv")), "env", jni("env")),
+		varDecl(type$5("lucent::jni::LocalFrame"), "frame_", env, { style: "construct" }),
+		varDecl(type$5("jclass"), "cls_", jni("findClass", javaClass(em, `kotlin/jvm/functions/Function${arity}`)), { static: true }),
+		varDecl(auto$1, "id_", jni("method", id("cls_"), str$5("invoke"), javaDescriptor(em, `(${"Ljava/lang/Object;".repeat(arity)})Ljava/lang/Object;`)), { static: true }),
+		varDecl(auto$1, "r_", call),
+		exprStmt$4(jni("check", env)),
+		...result ? [ret$3(result)] : []
+	];
+	const lambda = lambda$2([{
+		name: "f_",
+		init: jni("wrap", env, code, str$5(what))
+	}], params, body, { ret: em.reg.cppRetType(fn.ret) });
+	const value = construct(em.reg.cppType(fn), [lambda]);
+	if (lt.k !== "opt") return value;
+	const optional = em.reg.cppType(lt);
+	return conditional$1(code, construct(optional, [value]), construct(optional, [id("lucent::null")]));
+}
 function extendsSdk(base, to) {
 	for (let t = base; t;) {
 		if (t.module === to.module && t.name === to.name) return true;
@@ -29013,7 +30353,7 @@ function javaObjectOfClass(em, e, to, node) {
 	const o = id("o_");
 	return statementExpr([varDecl(auto$1, "o_", e.c)], jni("proxyFor", jni("env"), javaClass(em, iface.native), call$5(dot(o, "get")), initList(entries)));
 }
-function boxJava(node, t, c, what, lt) {
+function boxJava(em, node, t, c, what, lt) {
 	if (t.k === "string") return jni("toJString", env, c);
 	if (t.k === "tparam") {
 		const inner = lt ? stripOpt(lt) : void 0;
@@ -29022,6 +30362,7 @@ function boxJava(node, t, c, what, lt) {
 		if (inner?.k === "boolean" && lt.k !== "opt") return jni("boxBoolean", env, c);
 		fail$2(node, Codes.UnsupportedType, `${what} returns a type parameter's value: Lucent functions return an SDK object, a string or a boolean there`);
 	}
+	if (t.k === "ref") return envCall("NewLocalRef", toJavaObjectOf(em, t, c, lt, what));
 	if (t.k !== "prim") throw new Error(`${what}: a ${t.k} result its plan refuses`);
 	return boxedForJava(t, c, `${what}'s result`);
 }
@@ -29293,6 +30634,10 @@ function fromJni(em, code, t, lt, what, node) {
 			t: lt
 		};
 		case "tparam": return fromJavaObject(code, lt, what, node);
+		case "fn": return {
+			c: fromKotlinFunction(em, code, t, lt, what, node),
+			t: lt
+		};
 		default: throw new Error(`unsupported Java result type ${t.k}`);
 	}
 }
@@ -29319,14 +30664,14 @@ function fromJniList(em, code, t, lt, what, node) {
 function jniCall(em, opts) {
 	const result = opts.ret.k === "prim" && opts.ret.name === "void";
 	const out = fromJni(em, id("r_"), opts.ret, opts.lt, opts.what, opts.node);
-	const id$6 = id("id_");
+	const id$7 = id("id_");
 	const body = [
 		varDecl(pointer(type$5("JNIEnv")), "env", jni("env")),
 		...opts.pre ?? [],
 		varDecl(type$5("lucent::jni::LocalFrame"), "frame_", env, { style: "construct" }),
 		varDecl(type$5("jclass"), "cls_", jni("findClass", javaClass(em, opts.cls.native)), { static: true }),
 		varDecl(auto$1, "id_", jni(opts.lookup, id("cls_"), str$5(opts.name), javaDescriptor(em, opts.desc)), { static: true }),
-		result ? exprStmt$4(opts.access(id$6)) : varDecl(auto$1, "r_", opts.access(id$6)),
+		result ? exprStmt$4(opts.access(id$7)) : varDecl(auto$1, "r_", opts.access(id$7)),
 		exprStmt$4(jni("check", env)),
 		ret$3(result ? id("lucent::undefined") : out.c)
 	];
@@ -29344,7 +30689,7 @@ function argsOf(node) {
 function needOf(platform, since) {
 	if (typeof since !== (platform === "android" ? "number" : "string")) return void 0;
 	const version = String(since);
-	return compareVersions(version, platform === "ios" ? "15.1" : String(24)) > 0 ? {
+	return compareVersions(version, platform === "ios" ? oldestIos() : String(24)) > 0 ? {
 		platform,
 		version
 	} : void 0;
@@ -29356,7 +30701,7 @@ function availableArgs(need) {
 function requireAvailable(em, node, ref, since, what) {
 	const need = needOf(ref.platform, since);
 	if (!need || guarded(em, node, need)) return;
-	fail$2(node, Codes.Unavailable, need.platform === "ios" ? `${what} needs iOS ${need.version} (apps run from iOS ${MIN_IOS}): use it under if (available("ios", ${availableArgs(need)}))` : `${what} needs API ${need.version} (apps run from API 24): use it under if (available("android", ${need.version})) or Build_VERSION.SDK_INT >= ${need.version}`);
+	fail$2(node, Codes.Unavailable, need.platform === "ios" ? `${what} needs iOS ${need.version} (apps run from iOS ${oldestIos()}): use it under if (available("ios", ${availableArgs(need)}))` : `${what} needs API ${need.version} (apps run from API 24): use it under if (available("android", ${need.version})) or Build_VERSION.SDK_INT >= ${need.version}`);
 }
 const API_LEVEL = "jvm:android/os/Build$VERSION#SDK_INT:I";
 function apiLevelRead(em, e) {
@@ -29497,6 +30842,7 @@ function iosSuperInit(em, node, base, subclass) {
 	if (!ref || !decl || !ts.isConstructorDeclaration(decl)) fail$2(node, Codes.UnsupportedCall, `${base.name} cannot be constructed`);
 	const ctor = schemaConstructor(ref, decl);
 	if (ctor.swift) fail$2(node, Codes.UnsupportedClassFeature, `${base.name}: Swift initializers cannot be inherited`);
+	if (ctor.factory) fail$2(node, Codes.UnsupportedClassFeature, `${base.name}: ${ctor.selector} makes its own object (a class method Swift imports as an initializer), so a subclass cannot call it as super(…): call another of ${base.name}'s initializers`);
 	const plan = requirePlan(node, ref, ctor, "new");
 	requireAvailable(em, node, ref, ctor.since, `new ${base.name}(…)`);
 	noteIncludes(em, ref);
@@ -29541,7 +30887,14 @@ function nativeNew(em, node, t) {
 	noteIncludes(em, ref);
 	if (ref.platform === "ios") {
 		const a = args.map((x, i) => toObjc(em, x, params[i], plan));
-		const created = send(send$1(ref.cls.native, "alloc"), ctor.selector ?? "init", a);
+		if (ctor.cFunction) {
+			const made = cast$3("bridge_transfer", type$5("id"), call$5(ctor.cFunction.name, a));
+			return {
+				c: call$5("lucent::objc::wrap", [made, str$5(`new ${t.name}`)]),
+				t
+			};
+		}
+		const created = send(ctor.factory ? id(ref.cls.native) : send$1(ref.cls.native, "alloc"), ctor.selector ?? "init", a);
 		return {
 			c: call$5("lucent::objc::wrap", [created, str$5(`new ${t.name}`)]),
 			t
@@ -29602,7 +30955,7 @@ function nativeStaticProperty(em, node) {
 		}
 		return;
 	}
-	if (!ts.isPropertyDeclaration(decl)) return void 0;
+	if (!isSdkPropertyDecl(decl)) return void 0;
 	const ref = classOfDecl(decl);
 	if (!ref || !ts.getModifiers(decl)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) return void 0;
 	const found = schemaProperty(ref, decl);
@@ -29655,7 +31008,7 @@ function nativeMember(em, obj, node) {
 	if (obj.t.k === "native" && obj.t.module === "lucent:ios" && obj.t.name === "Out" && ts.isIdentifier(name) && name.text === "value") return outValue(em, obj, name.parent);
 	const decl = resolved(em, name)?.valueDeclaration;
 	const ref = decl ? classOfDecl(decl) : void 0;
-	if (!ref || !decl || !ts.isPropertyDeclaration(decl)) fail$2(node, Codes.UnsupportedSyntax, "methods of platform objects must be called directly");
+	if (!ref || !decl || !isSdkPropertyDecl(decl)) fail$2(node, Codes.UnsupportedSyntax, "methods of platform objects must be called directly");
 	const found = schemaProperty(ref, decl);
 	return property$1(em, node, found.ref, found.property, obj);
 }
@@ -29688,6 +31041,7 @@ function property$1(em, node, ref, prop, obj) {
 	const lt = declaredLt(em, ref.platform, t, node);
 	if (ref.platform === "ios") {
 		if (prop.global) return fromObjc(em, id(prop.global), t, lt, what);
+		if (prop.cFunctions) return fromObjc(em, call$5(prop.cFunctions.getter, obj ? [cfReceiver(ref, obj)] : []), t, lt, what);
 		return fromObjc(em, send(objcReceiver(ref, obj), prop.selector ?? prop.name, []), t, lt, what);
 	}
 	if (plan.backend === "kotlin-shim") return kotlinCall(em, {
@@ -29725,7 +31079,7 @@ function property$1(em, node, ref, prop, obj) {
 		lookup: obj ? "field" : "staticField",
 		name: prop.name,
 		desc: sig,
-		access: (id$7) => obj ? envCall(`Get${kind}Field`, jni("unwrap", id("recv_")), id$7) : envCall(`GetStatic${kind}Field`, id("cls_"), id$7),
+		access: (id$12) => obj ? envCall(`Get${kind}Field`, jni("unwrap", id("recv_")), id$12) : envCall(`GetStatic${kind}Field`, id("cls_"), id$12),
 		ret: t,
 		lt,
 		what,
@@ -29793,7 +31147,13 @@ function iosCall(em, node, ref, m, obj, plan, superOf) {
 	const a = argsOf(node).map((x, i) => toObjc(em, x, parseSdkType(m.params[i].type, ref.module, tps), plan));
 	const throws = plan.error?.detail === "nserror-out";
 	const selector = m.selector ?? m.name;
-	const code = superOf ? send(cast$3("c", objcPointer(superOf), call$5("lucent::objc::unwrap", [obj.c])), superSelector(selector), a, throws) : send(objcReceiver(ref, obj), selector, a, throws);
+	const c = m.cFunction;
+	const cArgs = c && obj && c.self !== void 0 ? [
+		...a.slice(0, c.self),
+		cfReceiver(ref, obj),
+		...a.slice(c.self)
+	] : a;
+	const code = c ? call$5(c.name, cArgs) : superOf ? send(cast$3("c", objcPointer(superOf), call$5("lucent::objc::unwrap", [obj.c])), superSelector(selector), a, throws) : send(objcReceiver(ref, obj), selector, a, throws);
 	const ret = parseSdkType(m.returns, ref.module, tps);
 	const what = `${ref.cls.name}.${m.name}()`;
 	const lt = declaredLt(em, "ios", ret, node);
@@ -29802,6 +31162,9 @@ function iosCall(em, node, ref, m, obj, plan, superOf) {
 	return fromObjc(em, code, ret, lt, what, owned);
 }
 const superSelector = (selector) => `lucentSuper_${selector}`;
+function cfReceiver(ref, obj) {
+	return cast$3("bridge", type$5(ref.cls.native), call$5("lucent::objc::unwrap", [obj.c]));
+}
 function objcReceiver(ref, obj) {
 	if (!obj) return id(ref.cls.native);
 	const type = ref.cls.interface ? protocol(ref.cls.native) : objcPointer(ref.cls.native);
@@ -29818,32 +31181,44 @@ function nativeLvalue(em, target, obj) {
 	}
 	const decl = resolved(em, target.name)?.valueDeclaration;
 	const declaring = decl ? classOfDecl(decl) : void 0;
-	if (!declaring || !decl || !ts.isPropertyDeclaration(decl)) return void 0;
+	if (!declaring || !decl || !isSdkPropertyDecl(decl)) return void 0;
 	const found = schemaProperty(declaring, decl);
 	if (!found || !!found.property.static !== !obj) return void 0;
 	const { ref, property: prop } = found;
-	const plan = requirePlan(target, ref, prop, "set");
+	const type = em.lt(target);
+	const set = propertySetter(em, target, ref, prop, obj, type);
 	const get = property$1(em, target, ref, prop, obj);
+	if (ref.platform !== "android" || !prop.setter) return {
+		get: get.c,
+		set,
+		type
+	};
+	const assign = (v) => propertySetter(em, target, ref, prop, obj, v.t)(v.c);
+	return {
+		get: get.c,
+		set,
+		assign,
+		type
+	};
+}
+function propertySetter(em, site, ref, prop, obj, type) {
+	const plan = requirePlan(site, ref, prop, "set");
 	const t = parseSdkType(prop.type, ref.module);
-	const type = em.lt(target);
 	if (prop.swift) {
 		const what = `${ref.cls.name}.${prop.name}`;
-		const use = swiftUse(target, ref, prop, "set", [t], VOID, what, !obj);
-		return {
-			get: get.c,
-			set: (v) => swiftSet(em, use, obj, v),
-			type
-		};
+		const use = swiftUse(site, ref, prop, "set", [t], VOID, what, !obj);
+		return (v) => swiftSet(em, use, obj, v);
 	}
 	if (ref.platform === "ios") {
 		const set = (value) => {
 			const v = id("v_");
-			const one = (x) => t.k === "fn" ? objcBlock(em, target, x, type, t, plan) : toObjcExpr({
+			const one = (x) => t.k === "fn" ? objcBlock(em, site, x, type, t, plan) : toObjcExpr({
 				...t,
 				nullable: false
 			}, x, false, `${ref.cls.name}.${prop.name}`);
 			const conv = t.nullable ? ifPresent(v, one) : one(v);
 			const held = varDecl(auto$1, "v_", value);
+			if (prop.cFunctions?.setter) return statementExpr([held, exprStmt$4(call$5(prop.cFunctions.setter, [...obj ? [cfReceiver(ref, obj)] : [], conv]))], v);
 			if (!prop.weak) return statementExpr([held, exprStmt$4(send(objcReceiver(ref, obj), prop.setter, [conv]))], v);
 			const [r, o] = [id("r_"), id("o_")];
 			const keep = call$5("objc_setAssociatedObject", [
@@ -29860,40 +31235,50 @@ function nativeLvalue(em, target, obj) {
 				exprStmt$4(send(r, prop.setter, [o]))
 			], v);
 		};
-		return {
-			get: get.c,
-			set,
-			type
-		};
+		return set;
 	}
 	if (!prop.setter) throw new Error(`${plan.display}: a Java field write its plan refuses`);
-	const desc = ref.cls.methods?.find((m) => (m.java ?? m.name) === prop.setter && m.params.length === 1)?.descriptor ?? jniDescriptor([prop.type], "void");
+	const what = `${ref.cls.name}.${prop.name}`;
+	const shim = plan.backend === "kotlin-shim" ? kotlinShim(em.ctx, {
+		node: site,
+		module: ref.module,
+		cls: ref.cls,
+		role: "set",
+		member: prop,
+		instance: !!obj,
+		given: [],
+		wrapped: [],
+		returns: VOID,
+		what
+	}) : void 0;
+	const desc = shim?.descriptor ?? ref.cls.methods?.find((m) => (m.java ?? m.name) === prop.setter && m.params.length === 1)?.descriptor ?? jniDescriptor([prop.type], "void");
+	const recv = obj ? [jni("unwrap", id("recv_"))] : [];
 	const set = (value) => {
 		const v = id("v_");
-		const converted = jniOf(em, target, t, {
+		const converted = jniOf(em, site, t, jniValue(em, ref, site, t, {
 			c: v,
 			t: type
-		});
+		}));
 		const call = jniCall(em, {
-			node: target,
-			cls: ref.cls,
-			lookup: obj ? "method" : "staticMethod",
-			name: prop.setter,
+			node: site,
+			cls: shim ? {
+				kind: "class",
+				name: shim.name,
+				native: shim.owner
+			} : ref.cls,
+			lookup: obj && !shim ? "method" : "staticMethod",
+			name: shim?.name ?? prop.setter,
 			desc,
-			access: (id$5) => envCall(`Call${obj ? "" : "Static"}VoidMethod`, obj ? jni("unwrap", id("recv_")) : id("cls_"), id$5, converted),
+			access: (id$4) => shim ? envCall("CallStaticVoidMethod", id("cls_"), id$4, ...recv, converted) : envCall(`Call${obj ? "" : "Static"}VoidMethod`, recv[0] ?? id("cls_"), id$4, converted),
 			ret: VOID,
 			lt: T.undefined,
-			what: `${ref.cls.name}.${prop.name}`,
+			what,
 			pre: obj ? [varDecl(auto$1, "recv_", obj.c)] : []
 		});
 		return statementExpr([varDecl(auto$1, "v_", value), exprStmt$4(call.c)], v);
 	};
 	noteIncludes(em, ref);
-	return {
-		get: get.c,
-		set,
-		type
-	};
+	return set;
 }
 function nativeFunctionCall(em, node) {
 	if (!ts.isIdentifier(node.expression)) return void 0;
@@ -29912,17 +31297,17 @@ function nativeFunctionCall(em, node) {
 	const ret = parseSdkType(f.returns, sdk.module);
 	return fromObjc(em, call$5(name, a), ret, declaredLt(em, "ios", ret, node), `${name}()`, owned);
 }
-function nativeConstant(em, id$8) {
-	const decl = resolved(em, id$8)?.valueDeclaration;
+function nativeConstant(em, id$13) {
+	const decl = resolved(em, id$13)?.valueDeclaration;
 	const sdk = decl && ts.isVariableDeclaration(decl) ? sdkModuleOf(decl.getSourceFile()) : void 0;
 	if (!sdk) return void 0;
-	const c = findSdkModule(sdk.platform, sdk.module).constants?.find((x) => x.name === id$8.text);
-	if (!c) fail$2(id$8, Codes.UnsupportedSyntax, `${id$8.text} has no binding`);
-	requirePlan(id$8, sdk, c, "get");
+	const c = findSdkModule(sdk.platform, sdk.module).constants?.find((x) => x.name === id$13.text);
+	if (!c) fail$2(id$13, Codes.UnsupportedSyntax, `${id$13.text} has no binding`);
+	requirePlan(id$13, sdk, c, "get");
 	const ct = parseSdkType(c.type, sdk.module);
-	if (c.swift) return swiftCall(em, swiftUse(id$8, sdk, c, "get", [], ct, c.name, true), void 0, []);
+	if (c.swift) return swiftCall(em, swiftUse(id$13, sdk, c, "get", [], ct, c.name, true), void 0, []);
 	noteFramework(em, sdk.module);
-	return fromObjc(em, id(c.name), ct, declaredLt(em, "ios", ct, id$8), c.name);
+	return fromObjc(em, id(c.name), ct, declaredLt(em, "ios", ct, id$13), c.name);
 }
 function noteFramework(em, module) {
 	const schema = loadSdkModule("ios", module);
@@ -29936,6 +31321,7 @@ function linkModule(em, schema) {
 	for (const f of schema.frameworks ?? []) em.ctx.frameworks.add(f);
 	const artifact = schema.provenance?.artifact;
 	if (artifact?.startsWith("pod:")) em.ctx.pods.add(artifact.slice(4).split("@")[0]);
+	if (artifact?.startsWith("spm:")) em.ctx.swiftPackages.add(artifact.slice(4));
 }
 function androidCall(em, node, ref, m, obj, plan) {
 	const tps = m.typeParams ?? [];
@@ -30109,6 +31495,12 @@ function nativeBuiltinCall(em, node) {
 				c: call$5("lucent::jni::currentActivity"),
 				t: em.lt(node)
 			};
+		case "lucent:android.errorOf":
+			unit.include("lucent/platform/android.h");
+			return {
+				c: call$5("lucent::jni::errorOf", [em.exprAs(args[0], declaredArg(em, args[0]))]),
+				t: T.error
+			};
 		case "lucent:android.startActivityForResult":
 		case "lucent:android.requestPermissions": {
 			unit.include("lucent/platform/android.h");
@@ -30185,7 +31577,7 @@ function kotlinCall(em, call) {
 			lookup: "staticMethod",
 			name: shim.name,
 			desc: shim.descriptor,
-			access: (id$4) => envCall(`CallStatic${kind}Method`, id("cls_"), id$4, ...recv, ...a),
+			access: (id$6) => envCall(`CallStatic${kind}Method`, id("cls_"), id$6, ...recv, ...a),
 			ret: returns,
 			lt: call.lt ?? declaredLt(em, "android", returns, node),
 			what,
@@ -30268,6 +31660,200 @@ function nativeInstanceOf(em, node) {
 		t: T.boolean
 	};
 }
+function sdkTagClass(em, tag) {
+	return ts.isIdentifier(tag) || ts.isPropertyAccessExpression(tag) ? sdkClassNamed(em, tag) : void 0;
+}
+function viewNew(em, site, ref, construction, lt) {
+	const owner = findSdkType(ref.platform, construction.module, construction.owner);
+	const declaring = owner?.kind === "class" ? {
+		...ref,
+		module: construction.module,
+		cls: owner
+	} : ref;
+	const what = `<${ref.cls.name}>`;
+	requireMain(em, site, ref);
+	requirePlan(site, declaring, construction.ctor, "new");
+	requireAvailable(em, site, ref, ref.cls.since, ref.cls.name);
+	requireAvailable(em, site, ref, construction.ctor.since, what);
+	if (construction.ctor.swift) fail$2(site, Codes.NativeViewJsx, `${ref.cls.name} is made through Swift: make it with create={() => new ${ref.cls.name}(…)}`);
+	noteIncludes(em, ref);
+	if (ref.platform === "ios") {
+		const alloc = send$1(ref.cls.native, "alloc");
+		const frame = construction.kind === "frame" ? [id("CGRectZero")] : [];
+		const made = send(alloc, construction.ctor.selector ?? "init", frame);
+		return {
+			c: call$5("lucent::objc::wrap", [made, str$5(what)]),
+			t: lt
+		};
+	}
+	const self = {
+		k: "ref",
+		module: ref.module,
+		name: ref.cls.name,
+		nullable: false
+	};
+	const desc = construction.ctor.descriptor ?? jniDescriptor(construction.ctor.params.map((p) => p.type), "void");
+	return jniCall(em, {
+		node: site,
+		cls: ref.cls,
+		lookup: "method",
+		name: "<init>",
+		desc,
+		access: (id$10) => envCall("NewObject", id("cls_"), id$10, jni("unwrap", id("context_"))),
+		ret: self,
+		lt,
+		what,
+		pre: [varDecl(auto$1, "context_", jni("viewContext"))]
+	});
+}
+function takes(t, lt) {
+	const v = stripOpt(lt);
+	switch (t.k) {
+		case "string": return v.k === "string";
+		case "prim": return t.name === "boolean" || t.name === "bool" ? v.k === "boolean" : isWideInteger(t.name) ? v.k === "bigint" : v.k === "number";
+		default: return ![
+			"string",
+			"boolean",
+			"number",
+			"bigint"
+		].includes(v.k);
+	}
+}
+function jniValue(em, ref, site, t, value) {
+	const as = (lt) => ({
+		c: em.coerce(value, lt, site),
+		t: lt
+	});
+	switch (t.k) {
+		case "prim": return as(primLt(t));
+		case "string": return as(t.nullable ? unionOf([T.string, T.null]) : T.string);
+		case "array": {
+			const lt = declaredLt(em, ref.platform, {
+				...t,
+				nullable: false
+			}, site);
+			return as(t.nullable ? unionOf([lt, T.null]) : lt);
+		}
+		case "ref": {
+			if (value.t.k === "fn" || eitherMembers(value.t)) return value;
+			const lt = {
+				k: "native",
+				platform: ref.platform,
+				module: t.module,
+				name: t.name
+			};
+			return as(t.nullable ? unionOf([lt, T.null]) : lt);
+		}
+		default: return value;
+	}
+}
+function setterCall(em, site, ref, overloads, obj, value) {
+	const method = overloads.find((m) => takes(parseSdkType(m.params[0].type, ref.module), value.t)) ?? overloads[0];
+	const t = parseSdkType(method.params[0].type, ref.module);
+	const what = `${ref.cls.name}.${method.name}`;
+	requirePlan(site, ref, method, "call");
+	requireMain(em, site, ref, method);
+	requireAvailable(em, site, ref, method.since, what);
+	noteIncludes(em, ref);
+	return jniCall(em, {
+		node: site,
+		cls: ref.cls,
+		lookup: "method",
+		name: method.java ?? method.name,
+		desc: method.descriptor ?? jniDescriptor([method.params[0].type], "void"),
+		access: (id$11) => envCall("CallVoidMethod", jni("unwrap", id("recv_")), id$11, jniOf(em, site, t, jniValue(em, ref, site, t, value))),
+		ret: VOID,
+		lt: T.undefined,
+		what,
+		pre: [varDecl(auto$1, "recv_", obj.c)]
+	}).c;
+}
+function insertChild(em, site, ref, method, parent, child, index) {
+	const what = `${ref.cls.name}.${method.selector ?? method.name}`;
+	const childType = parseSdkType(method.params[0].type, ref.module);
+	requirePlan(site, ref, method, "call");
+	requireMain(em, site, ref, method);
+	requireAvailable(em, site, ref, method.since, what);
+	noteIncludes(em, ref);
+	if (ref.platform === "ios") return send(objcReceiver(ref, parent), method.selector, [toObjcExpr({
+		...childType,
+		nullable: false
+	}, child.c, false, what), num$5(index)]);
+	return jniCall(em, {
+		node: site,
+		cls: ref.cls,
+		lookup: "method",
+		name: method.java ?? method.name,
+		desc: method.descriptor ?? jniDescriptor(method.params.map((p) => p.type), "void"),
+		access: (id$8) => envCall("CallVoidMethod", jni("unwrap", id("recv_")), id$8, jni("unwrap", id("child_")), staticCast(type$5("jint"), num$5(index))),
+		ret: VOID,
+		lt: T.undefined,
+		what,
+		pre: [varDecl(auto$1, "recv_", parent.c), varDecl(auto$1, "child_", child.c)]
+	}).c;
+}
+function listenerEvent(em, site, ref, setter, obj, handler) {
+	const listener = parseSdkType(setter.params[0].type, ref.module);
+	if (listener.k !== "ref") throw new Error(`${setter.name}: its listener is no class`);
+	const what = `${ref.cls.name}.${setter.name}`;
+	requirePlan(site, ref, setter, "call");
+	requireMain(em, site, ref, setter);
+	requireAvailable(em, site, ref, setter.since, what);
+	noteIncludes(em, ref);
+	const call = (given) => jniCall(em, {
+		node: site,
+		cls: ref.cls,
+		lookup: "method",
+		name: setter.java ?? setter.name,
+		desc: setter.descriptor ?? jniDescriptor([setter.params[0].type], "void"),
+		access: (id$5) => envCall("CallVoidMethod", jni("unwrap", id("recv_")), id$5, given),
+		ret: VOID,
+		lt: T.undefined,
+		what,
+		pre: [varDecl(auto$1, "recv_", obj.c)]
+	}).c;
+	return {
+		add: call(javaProxy(em, site, handler, {
+			...listener,
+			nullable: false
+		})),
+		remove: call(id("nullptr"))
+	};
+}
+function controlEvent(em, site, ref, tag, register, value, obj, handler) {
+	const what = `${ref.cls.name}.${register.selector}`;
+	const fn = {
+		k: "fn",
+		params: [{
+			k: "ref",
+			module: tag.module,
+			name: tag.cls.name,
+			nullable: false
+		}],
+		ret: VOID,
+		escaping: true,
+		main: true,
+		nullable: false
+	};
+	requirePlan(site, ref, register, "call");
+	requireAvailable(em, site, ref, register.since, what);
+	noteIncludes(em, ref);
+	em.ctx.nativeUnit(em.opts.module).include("lucent/platform/ios_ui.h");
+	const block = objcBlock(em, site, handler.c, handler.t, fn, { display: what });
+	const control = call$5("lucent::objc::unwrap", [obj.c]);
+	return {
+		add: call$5("lucent::objc::addControlAction", [
+			control,
+			num$5(value),
+			block
+		]),
+		remove: (action) => call$5("lucent::objc::removeControlAction", [
+			control,
+			action,
+			num$5(value)
+		])
+	};
+}
 //#endregion
 //#region ../compiler/src/emit/extensions.ts
 function handleNew(em, node, t) {
@@ -31529,6 +33115,7 @@ var FnEmitter = class {
 		const il = this.intLocal(target);
 		if (il) return staticCast(type$5("double"), assign$4(id(il.cpp), this.toKind(value, il.int, node)));
 		const lv = this.lvalue(target);
+		if (lv.assign) return lv.assign(value);
 		const v = this.coerce(value, lv.type, node);
 		if (lv.direct) return assign$4(lv.direct, v);
 		return lv.set(v);
@@ -31662,7 +33249,8 @@ var FnEmitter = class {
 	lvalueType(target) {
 		try {
 			if (ts.isArrayLiteralExpression(target)) return void 0;
-			return this.lvalue(target).type;
+			const lv = this.lvalue(target);
+			return lv.assign ? void 0 : lv.type;
 		} catch {
 			return;
 		}
@@ -33070,7 +34658,7 @@ function leafHost(ctx, opts) {
 		place: (target, operands) => {
 			const lv = new LeafEmitter(ctx, opts, target, operands).lvalue(target);
 			const name = nameOf$2(target);
-			const { direct, set } = lv;
+			const { direct, set, assign } = lv;
 			if (!direct && !set) throw new IrUnsupported(target, "a place that cannot be written");
 			return {
 				type: lv.type,
@@ -33083,7 +34671,15 @@ function leafHost(ctx, opts) {
 					name: `${name} =`,
 					code: direct ? assign$4(direct, operand(v)) : set(operand(v)),
 					type: T.void
-				})
+				}),
+				...assign ? { assign: (v, from) => ({
+					name: `${name} =`,
+					code: assign({
+						c: operand(v),
+						t: from
+					}),
+					type: T.void
+				}) } : {}
 			};
 		}
 	};
@@ -38291,7 +39887,7 @@ function emitProgram(lp, target = lp.platform ?? "all", components = /* @__PURE_
 		decls: [
 			{ k: "pragmaOnce" },
 			include("lucent/lucent.h", true),
-			...lp.modules.some((m) => /["']lucent:ui["']/.test(m.sourceFile.text)) ? [include("lucent/view.h", true)] : [],
+			...setups.size || lp.modules.some((m) => /["']lucent:ui["']/.test(m.sourceFile.text)) ? [include("lucent/view.h", true)] : [],
 			...shielded([...readers.decls.length ? [
 				app(types),
 				namespace("lucent", readers.decls),
@@ -38361,6 +39957,7 @@ function emitProgram(lp, target = lp.platform ?? "all", components = /* @__PURE_
 		warnings: ctx.warnings,
 		frameworks: [...ctx.frameworks].sort(),
 		pods: [...ctx.pods].sort(),
+		swiftPackages: [...ctx.swiftPackages].sort(),
 		java,
 		javaKeep: [...ctx.javaClasses].sort(),
 		kotlin: new Map([...kotlinFiles(ctx), ...toolkitFiles(ctx, "compose")]),
@@ -40432,21 +42029,21 @@ function attributes(from, names) {
 	return Object.fromEntries(names.filter((n) => from[n] !== void 0).map((n) => [`android:${n}`, String(from[n])]));
 }
 function componentElement(c) {
-	const named = (tag) => (name) => element$1(tag, { "android:name": name });
-	const children = [...(c.intentFilters ?? []).map((f) => element$1("intent-filter", {}, [
+	const named = (tag) => (name) => element$2(tag, { "android:name": name });
+	const children = [...(c.intentFilters ?? []).map((f) => element$2("intent-filter", {}, [
 		...f.actions.map(named("action")),
 		...(f.categories ?? []).map(named("category")),
-		...(f.data ?? []).map((d) => element$1("data", attributes(d, DATA_ATTRIBUTES)))
-	])), ...Object.entries(c.metaData ?? {}).map(([name, value]) => element$1("meta-data", {
+		...(f.data ?? []).map((d) => element$2("data", attributes(d, DATA_ATTRIBUTES)))
+	])), ...Object.entries(c.metaData ?? {}).map(([name, value]) => element$2("meta-data", {
 		"android:name": name,
 		"android:value": value
 	}))];
-	return element$1(c.kind, attributes(c, COMPONENT_ATTRIBUTES), children.length ? children : void 0);
+	return element$2(c.kind, attributes(c, COMPONENT_ATTRIBUTES), children.length ? children : void 0);
 }
 function androidManifest(permissions, components = []) {
 	return printDocument({
 		comment: "Generated by Lucent. Do not edit.",
-		root: element$1("manifest", { "xmlns:android": "http://schemas.android.com/apk/res/android" }, [...permissions.map((p) => element$1("uses-permission", { "android:name": p })), element$1("application", {}, [...RUNTIME_COMPONENTS, ...components].map(componentElement))])
+		root: element$2("manifest", { "xmlns:android": "http://schemas.android.com/apk/res/android" }, [...permissions.map((p) => element$2("uses-permission", { "android:name": p })), element$2("application", {}, [...RUNTIME_COMPONENTS, ...components].map(componentElement))])
 	});
 }
 function consumerRules(classes) {
@@ -40462,6 +42059,27 @@ function jsxToolkits() {
 	return Object.fromEntries(Object.keys(TOOLKITS).map((name) => [TOOLKITS[name].platform, name]));
 }
 //#endregion
+//#region ../compiler/src/ui/view-coverage.ts
+function viewCoverage(schema, moduleOf) {
+	if (!fabricRequested()) return void 0;
+	const find = (module, name) => module === schema.module ? schema.types.find((t) => t.name === name) : moduleOf(module)?.types.find((t) => t.name === name);
+	return schema.types.filter((t) => t.kind === "class" && !t.interface && isViewClass(t, schema, find)).map((cls) => {
+		const rules = viewRules(cls, schema, find);
+		const explained = (x) => ({
+			name: x.name,
+			explanation: x.explanation
+		});
+		return {
+			view: cls.name,
+			made: viewConstruction(cls, schema, find).kind,
+			props: rules.props.map(explained),
+			events: rules.events.map(explained),
+			...rules.children ? { children: rules.children.explanation } : {},
+			leftOut: rules.refused
+		};
+	});
+}
+//#endregion
 //#region ../compiler/src/ui/android.ts
 const JAVA = "android/src/main/java/dev/lucent";
 const DESCRIPTORS_HEADER = "android/include/react/renderer/components/lucentnative/ComponentDescriptors.h";
@@ -40609,8 +42227,8 @@ function writeNativePackage(result, outDir, options = {}) {
 		resources: inPackage(native?.ios.resources ?? []),
 		resourceBundles: Object.entries(native?.ios.resourceBundles ?? {}).map(([name, paths]) => [name, inPackage(paths)]),
 		vendoredFrameworks: inPackage(native?.ios.vendoredFrameworks ?? []),
-		swiftPackages: Object.entries(native?.ios.swiftPackages ?? {}),
-		deploymentTarget: native?.ios.deploymentTarget?.value
+		swiftPackages: [...Object.entries(native?.ios.swiftPackages ?? {}), ...appSwiftPackages(result.swiftPackages ?? [], options.app?.swiftPackages ?? [])],
+		deploymentTarget: highestVersion([native?.ios.deploymentTarget?.value, options.app?.deploymentTarget])
 	}));
 	const gradle = path.join(outDir, "android/build.gradle");
 	want.set(gradle, options.androidDeferred ? deferredLibraryGradle(options.native) : libraryBuildGradle(want.get(gradle).toString(), options.native, !!result.kotlin?.size, result.compose ? [...result.kotlin].filter(([f]) => f.startsWith("dev/lucent/compose/")).map(([, t]) => t) : []));
@@ -40680,6 +42298,21 @@ function writeWhole(file, content) {
 	fs.writeFileSync(tmp, content);
 	fs.renameSync(tmp, file);
 }
+function appSwiftPackages(used, pins) {
+	return pins.filter((p) => used.some((u) => u.slice(0, u.lastIndexOf("@")) === p.identity)).map((p) => [p.location, {
+		requirement: p.version ? {
+			kind: "exactVersion",
+			version: p.version
+		} : {
+			kind: "revision",
+			revision: p.revision
+		},
+		products: p.products
+	}]);
+}
+function highestVersion(versions) {
+	return versions.filter((v) => !!v).sort(compareVersions).at(-1);
+}
 //#endregion
 //#region ../compiler/src/sdk/modules.ts
 const composing = (platform) => platform === "android" && fabricRequested();
@@ -40768,6 +42401,7 @@ function compileWith(files, options) {
 		if (target === "ios") {
 			out.frameworks = result.frameworks;
 			out.pods = result.pods;
+			out.swiftPackages = result.swiftPackages;
 		}
 		if (target === "android") {
 			out.java = result.java;
@@ -40877,4 +42511,4 @@ function report(diagnostics) {
 	return diagnostics.map(formatDiagnostic).join("\n");
 }
 //#endregion
-export { sdkSchemaEntry as $, findLucentFiles as A, diffModule as B, bindExtensions as C, LUCENT_EXTENSION as D, identityScript as E, moduleNamespace as F, cachedModules as G, displayName as H, extensionDts as I, forgetLoadedSdks as J, cachedSchema as K, sdkDts as L, platformOf as M, projectFiles as N, coreJsPath as O, usesPlatforms as P, sdkNames as Q, coverage as R, inNativePackage as S, RUNTIME_ABI as T, symbolKey as U, diffSymbols as V, podsSearchPaths as W, sdkAvailable as X, prefetch as Y, sdkModuleArtifacts as Z, VIEW_CONTRACT_VERSION as _, report as a, PACKAGE_FIELDS as b, sdkModules as c, isUpToDate as d, sdkSourceModule as et, runtimeDir as f, libraryBuildGradle as g, toolkitsFrom as h, projectExtensions as i, moduleNameOf as j, coreTypesPath as k, deferredLibraryGradle as l, jsxToolkits as m, compile as n, sdkDeclarations as o, writeNativePackage as p, extractionCount as q, compileDirectory as r, sdkModule as s, checkSources as t, formatDiagnostic as tt, inputsKey as u, resolveNative as v, forgetExtensionHeaders as w, fileHashes as x, EXTENSION_FIELDS as y, compareArtifacts as z };
+export { sdkNames as $, coreTypesPath as A, compareArtifacts as B, inNativePackage as C, identityScript as D, RUNTIME_ABI as E, usesPlatforms as F, podsSearchPaths as G, diffSymbols as H, moduleNamespace as I, extractionCount as J, cachedModules as K, extensionDts as L, moduleNameOf as M, platformOf as N, LUCENT_EXTENSION as O, projectFiles as P, sdkModuleArtifacts as Q, sdkDts as R, fileHashes as S, forgetExtensionHeaders as T, displayName as U, diffModule as V, symbolKey as W, prefetch as X, forgetLoadedSdks as Y, sdkAvailable as Z, libraryBuildGradle as _, report as a, EXTENSION_FIELDS as b, sdkModules as c, isUpToDate as d, sdkSchemaEntry as et, runtimeDir as f, toolkitsFrom as g, jsxToolkits as h, projectExtensions as i, formatDiagnostic as it, findLucentFiles as j, coreJsPath as k, deferredLibraryGradle as l, viewCoverage as m, compile as n, cacheRoot as nt, sdkDeclarations as o, writeNativePackage as p, cachedSchema as q, compileDirectory as r, hash$2 as rt, sdkModule as s, checkSources as t, sdkSourceModule as tt, inputsKey as u, VIEW_CONTRACT_VERSION as v, bindExtensions as w, PACKAGE_FIELDS as x, resolveNative as y, coverage as z };