vxrn 2.0.0-beta.99.1 → 2.6.0

package/dist/utils/nativeSourceContract.mjs

@@ -0,0 +1,1823 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { swiftPackageDirectories, swiftPackageId } from "./swiftPackageId.mjs";
+
+const GENERATED_HEADER = "// generated by one typegen; edits will be replaced\n";
+const SKIP_SOURCE_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"ios",
+	"android",
+	"dist",
+	"types",
+	"build",
+	".build"
+]);
+function writeGeneratedFile(file, content) {
+	try {
+		if (readFileSync(file, "utf8") === content) return;
+	} catch (error) {
+		if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") throw error;
+	}
+	const temporary = join(dirname(file), `.${basename(file)}.${randomUUID()}.tmp`);
+	try {
+		writeFileSync(temporary, content);
+		renameSync(temporary, file);
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+}
+function fail(file, token, message) {
+	throw new Error(`${file}:${(token?.line ?? 0) + 1}:${(token?.column ?? 0) + 1}: ${message}`);
+}
+function tokens(file, source) {
+	const result = [];
+	let offset = 0;
+	let line = 0;
+	let column = 0;
+	const advance = () => {
+		if (source[offset] === "\n") {
+			line++;
+			column = 0;
+		} else column++;
+		offset++;
+	};
+	while (offset < source.length) {
+		const char = source[offset];
+		if (/\s/.test(char)) {
+			advance();
+			continue;
+		}
+		if (source.startsWith("//", offset)) {
+			while (offset < source.length && source[offset] !== "\n") advance();
+			continue;
+		}
+		if (source.startsWith("/*", offset)) {
+			let depth = 0;
+			do {
+				if (source.startsWith("/*", offset)) {
+					depth++;
+					advance();
+					advance();
+				} else if (source.startsWith("*/", offset)) {
+					depth--;
+					advance();
+					advance();
+				} else advance();
+			} while (depth > 0 && offset < source.length);
+			if (depth > 0) fail(file, {
+				text: "/*",
+				line,
+				column
+			}, "unclosed native source comment");
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			const quote = source.startsWith(char.repeat(3), offset) ? char.repeat(3) : char;
+			for (let n = 0; n < quote.length; n++) advance();
+			while (offset < source.length && !source.startsWith(quote, offset)) {
+				if (source[offset] === "\\") advance();
+				advance();
+			}
+			if (offset >= source.length) fail(file, {
+				text: quote,
+				line,
+				column
+			}, "unclosed native source string");
+			for (let n = 0; n < quote.length; n++) advance();
+			continue;
+		}
+		const start = offset;
+		const startLine = line;
+		const startColumn = column;
+		if (/[A-Za-z_]/.test(char)) {
+			while (offset < source.length && /[A-Za-z0-9_]/.test(source[offset])) advance();
+		} else if (source.startsWith("->", offset)) {
+			advance();
+			advance();
+		} else advance();
+		result.push({
+			text: source.slice(start, offset),
+			line: startLine,
+			column: startColumn
+		});
+	}
+	return result;
+}
+function close(file, list, start, left, right) {
+	let depth = 0;
+	for (let i = start; i < list.length; i++) {
+		if (list[i].text === left) depth++;
+		if (list[i].text === right && --depth === 0) return i;
+	}
+	fail(file, list[start], `unclosed ${left} in native export`);
+}
+function split(list, separator) {
+	const parts = [];
+	let start = 0;
+	let square = 0;
+	let angle = 0;
+	let round = 0;
+	for (let i = 0; i < list.length; i++) {
+		const value = list[i].text;
+		if (value === "[") square++;
+		if (value === "]") square--;
+		if (value === "<") angle++;
+		if (value === ">") angle--;
+		if (value === "(") round++;
+		if (value === ")") round--;
+		if (value === separator && square === 0 && angle === 0 && round === 0) {
+			parts.push(list.slice(start, i));
+			start = i + 1;
+		}
+	}
+	parts.push(list.slice(start));
+	return parts;
+}
+function arrayOf(element) {
+	return element.includes(" | ") ? `(${element})[]` : `${element}[]`;
+}
+function tsType(file, list, language, named) {
+	if (list.length === 0) fail(file, list[0], "native export needs an explicit type");
+	if (list.at(-1)?.text === "?") {
+		const inner = tsType(file, list.slice(0, -1), language, named);
+		return {
+			text: `${inner.text} | null`,
+			wire: inner.wire ? {
+				kind: "nullable",
+				inner: inner.wire
+			} : null
+		};
+	}
+	const value = list.map((token) => token.text).join("");
+	if (value === "String") return {
+		text: "string",
+		wire: null
+	};
+	if (value === "Bool" || value === "Boolean") return {
+		text: "boolean",
+		wire: null
+	};
+	if ([
+		"Double",
+		"Float",
+		"Int",
+		"Long"
+	].includes(value)) return {
+		text: "number",
+		wire: null
+	};
+	if (value === "Void" || value === "Unit") return {
+		text: "void",
+		wire: null
+	};
+	const dateTypes = language === "swift" ? ["Date", "Foundation.Date"] : ["Date", "java.util.Date"];
+	if (dateTypes.includes(value)) return {
+		text: "Date",
+		wire: { kind: "date" }
+	};
+	const dataTypes = language === "swift" ? ["Data", "Foundation.Data"] : ["ByteArray"];
+	if (dataTypes.includes(value)) {
+		return {
+			text: "Uint8Array",
+			wire: { kind: "data" }
+		};
+	}
+	if (language === "swift" && list[0].text === "[" && list.at(-1)?.text === "]") {
+		const inner = list.slice(1, -1);
+		const entries = split(inner, ":");
+		if (entries.length === 1) {
+			const element = tsType(file, inner, language, named);
+			return {
+				text: arrayOf(element.text),
+				wire: element.wire ? {
+					kind: "array",
+					element: element.wire
+				} : null
+			};
+		}
+		if (entries.length === 2 && entries[0].map((token) => token.text).join("") === "String") {
+			const element = tsType(file, entries[1], language, named);
+			return {
+				text: `Record<string, ${element.text}>`,
+				wire: element.wire ? {
+					kind: "map",
+					value: element.wire
+				} : null
+			};
+		}
+	}
+	if (language === "kotlin" && list[1]?.text === "<" && list.at(-1)?.text === ">") {
+		const entries = split(list.slice(2, -1), ",");
+		if (list[0].text === "List" && entries.length === 1) {
+			const element = tsType(file, entries[0], language, named);
+			return {
+				text: arrayOf(element.text),
+				wire: element.wire ? {
+					kind: "array",
+					element: element.wire
+				} : null
+			};
+		}
+		if (list[0].text === "Map" && entries.length === 2 && entries[0].map((token) => token.text).join("") === "String") {
+			const element = tsType(file, entries[1], language, named);
+			return {
+				text: `Record<string, ${element.text}>`,
+				wire: element.wire ? {
+					kind: "map",
+					value: element.wire
+				} : null
+			};
+		}
+	}
+	if (list.length === 1 && /^[A-Z][A-Za-z0-9_]*$/.test(value)) {
+		const struct = named.structs.get(value);
+		if (struct) {
+			if (struct.generic) fail(file, list[0], `generic struct ${value} is unsupported`);
+			if (struct.problem) fail(file, list[0], struct.problem);
+			if (!struct.codable) fail(file, list[0], `struct ${value} must conform to Codable to cross the boundary`);
+			return {
+				text: value,
+				wire: {
+					kind: "struct",
+					name: value
+				}
+			};
+		}
+		const enumType = named.enums.get(value);
+		if (enumType) {
+			if (!enumType.usable) fail(file, list[0], enumType.problem);
+			return {
+				text: value,
+				wire: {
+					kind: "enum",
+					name: value
+				}
+			};
+		}
+	}
+	fail(file, list[0], `unsupported native export type ${value}`);
+}
+function parameters(file, list, language, named) {
+	if (list.length === 0) return [];
+	return split(list, ",").map((part, index) => {
+		if (part.some((token) => token.text === "=")) fail(file, part[0], "default native export arguments are unsupported");
+		const colon = part.findIndex((token) => token.text === ":");
+		if (colon < 0) fail(file, part[0], "native export parameter needs an explicit type");
+		const names = part.slice(0, colon).filter((token) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(token.text));
+		const name = (language === "swift" ? names.at(-1) : names[0])?.text ?? `arg${index}`;
+		if (name === "_") fail(file, part[0], "native export parameter needs an internal name");
+		const label = language === "swift" ? names[0]?.text ?? name : null;
+		const sourceType = part.slice(colon + 1);
+		const type = tsType(file, sourceType, language, named);
+		return {
+			name,
+			label,
+			type: type.text,
+			nativeType: sourceType.map((token) => token.text).join(""),
+			wire: type.wire ?? void 0
+		};
+	});
+}
+const DECLARATION_MODIFIERS = /* @__PURE__ */ new Set([
+	"private",
+	"fileprivate",
+	"public",
+	"internal",
+	"open",
+	"override",
+	"static",
+	"class",
+	"final",
+	"suspend",
+	"inline",
+	"operator",
+	"infix",
+	"tailrec",
+	"external",
+	"nonisolated",
+	"isolated",
+	"mutating",
+	"nonmutating",
+	"dynamic",
+	"required",
+	"convenience",
+	"optional"
+]);
+function declarationStart(list, floor, keyword) {
+	let first = keyword;
+	while (first > floor) {
+		const text = list[first - 1].text;
+		if (DECLARATION_MODIFIERS.has(text)) {
+			first--;
+			continue;
+		}
+		if (list[first - 2]?.text === "@") {
+			first -= 2;
+			continue;
+		}
+		if (text === ")") {
+			let open = first - 1;
+			for (let depth = 0; open > floor; open--) {
+				if (list[open].text === ")") depth++;
+				if (list[open].text === "(" && --depth === 0) break;
+			}
+			if (list[open - 2]?.text === "@") {
+				first = open - 2;
+				continue;
+			}
+		}
+		break;
+	}
+	return first;
+}
+function subscriptionPayload(file, typeTokens, language, named) {
+	try {
+		if (typeTokens.at(-1)?.text === "?") return null;
+		let fn = typeTokens;
+		if (language === "swift" && fn[0]?.text === "@" && fn[1]?.text === "escaping") fn = fn.slice(2);
+		if (fn[0]?.text === "(" && close(file, fn, 0, "(", ")") === fn.length - 1 && fn.some((token) => token.text === "->")) {
+			fn = fn.slice(1, -1);
+		}
+		const arrow = fn.findIndex((token) => token.text === "->");
+		if (arrow <= 0 || fn[0]?.text !== "(" || close(file, fn, 0, "(", ")") !== arrow - 1) return null;
+		const result = fn.slice(arrow + 1);
+		const voidResult = result.length === 1 && (result[0].text === "Void" || result[0].text === "Unit") || result.length === 2 && result[0].text === "(" && result[1].text === ")";
+		if (!voidResult) return null;
+		const inner = fn.slice(1, arrow - 1);
+		if (inner.length === 0) return [];
+		return split(inner, ",").map((arg) => {
+			const colon = arg.findIndex((token) => token.text === ":");
+			const type = colon < 0 ? arg : arg.slice(colon + 1);
+			const resolved = tsType(file, type, language, named);
+			return {
+				type: resolved.text,
+				nativeType: type.map((token) => token.text).join(""),
+				wire: resolved.wire ?? void 0
+			};
+		});
+	} catch {
+		return null;
+	}
+}
+function methods(file, list, start, end, language, named) {
+	const result = [];
+	let i = start + 1;
+	let previous = i;
+	const keyword = language === "swift" ? "func" : "fun";
+	while (i < end) {
+		if (list[i].text === "{") {
+			i = close(file, list, i, "{", "}") + 1;
+			previous = i;
+			continue;
+		}
+		if (list[i].text !== keyword) {
+			i++;
+			continue;
+		}
+		const modifiers = list.slice(declarationStart(list, previous, i), i).map((token) => token.text);
+		const hidden = modifiers.includes("private") || modifiers.includes("fileprivate");
+		if (!hidden && (modifiers.includes("static") || modifiers.includes("class"))) {
+			fail(file, list[i], "static native exports are unsupported");
+		}
+		const name = list[i + 1]?.text;
+		if (!name || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) fail(file, list[i], "native export has no method name");
+		if (result.some((method) => method.name === name)) fail(file, list[i], `overloaded native export ${name} is unsupported`);
+		if (list[i + 2]?.text === "<") fail(file, list[i], "generic native exports are unsupported");
+		const open = i + 2;
+		if (list[open]?.text !== "(") fail(file, list[i], "native export has no parameter list");
+		const closing = close(file, list, open, "(", ")");
+		let headerEnd = closing + 1;
+		while (headerEnd < end && ![
+			"{",
+			"=",
+			";"
+		].includes(list[headerEnd].text)) headerEnd++;
+		const header = list.slice(closing + 1, headerEnd);
+		const separator = header.findIndex((token) => token.text === (language === "swift" ? "->" : ":"));
+		const sourceType = hidden || separator < 0 ? [] : header.slice(separator + 1);
+		const type = sourceType.length === 0 ? {
+			text: "void",
+			wire: null
+		} : tsType(file, sourceType, language, named);
+		let subscription;
+		if (!hidden && type.text === "void") {
+			const parts = split(list.slice(open + 1, closing), ",");
+			if (parts.length === 1 && parts[0].length > 0) {
+				const colon = parts[0].findIndex((token) => token.text === ":");
+				if (colon >= 0) {
+					const payload = subscriptionPayload(file, parts[0].slice(colon + 1), language, named);
+					if (payload) subscription = { payload };
+				}
+			}
+		}
+		if (!hidden) {
+			result.push({
+				name,
+				parameters: subscription ? [] : parameters(file, list.slice(open + 1, closing), language, named),
+				result: type.text,
+				nativeResult: sourceType.length === 0 ? language === "swift" ? "Void" : "Unit" : sourceType.map((token) => token.text).join(""),
+				resultWire: type.wire ?? void 0,
+				subscription,
+				throws: language === "swift" ? header.some((token) => token.text === "throws") : true,
+				async: language === "swift" ? header.some((token) => token.text === "async") : modifiers.includes("suspend")
+			});
+		}
+		if (list[headerEnd]?.text === "{") i = close(file, list, headerEnd, "{", "}") + 1;
+		else if (list[headerEnd]?.text === "=") {
+			const bodyLine = list[headerEnd].line;
+			i = headerEnd + 1;
+			while (i < end && list[i].line === bodyLine && list[i].text !== ";") i++;
+		} else i = headerEnd + 1;
+		previous = i;
+	}
+	return result;
+}
+function callbackProp(file, name, typeTokens, optional, language, named) {
+	const nullable = typeTokens.at(-1)?.text === "?";
+	let fn = nullable ? typeTokens.slice(0, -1) : typeTokens;
+	if (fn[0]?.text === "(" && close(file, fn, 0, "(", ")") === fn.length - 1 && fn.some((token) => token.text === "->")) {
+		fn = fn.slice(1, -1);
+	}
+	const arrow = fn.findIndex((token) => token.text === "->");
+	if (arrow < 0 || fn[0]?.text !== "(" || close(file, fn, 0, "(", ")") !== arrow - 1) return null;
+	const result = fn.slice(arrow + 1).map((token) => token.text).join("");
+	const unit = language === "swift" ? "Void" : "Unit";
+	if (result !== unit && !(language === "swift" && result === "()")) {
+		fail(file, typeTokens[0], `view callback ${name} must return ${unit}`);
+	}
+	const inner = fn.slice(1, arrow - 1);
+	const callback = inner.length === 0 ? [] : split(inner, ",").map((arg) => {
+		const colon = arg.findIndex((token) => token.text === ":");
+		const type = colon < 0 ? arg : arg.slice(colon + 1);
+		const resolved = tsType(file, type, language, named);
+		return {
+			type: resolved.text,
+			nativeType: type.map((token) => token.text).join(""),
+			wire: resolved.wire ?? void 0
+		};
+	});
+	const signature = `(${callback.map((arg, index) => `value${index}: ${arg.type}`).join(", ")}) => void`;
+	const nativeType = typeTokens.map((token) => token.text).join("");
+	return {
+		name,
+		type: nullable ? `(${signature}) | null` : signature,
+		nativeType,
+		optional,
+		callback
+	};
+}
+function viewProp(file, part, named) {
+	const colon = part.findIndex((token) => token.text === ":");
+	if (colon !== 1 || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(part[0].text)) {
+		fail(file, part[0], "composable parameter needs a name and an explicit type");
+	}
+	const name = part[0].text;
+	const equals = split(part.slice(colon + 1), "=");
+	const typeTokens = equals[0];
+	const fallback = equals[1]?.map((token) => token.text).join("");
+	const nativeType = typeTokens.map((token) => token.text).join("");
+	if (nativeType === "Modifier") {
+		if (fallback !== "Modifier") fail(file, part[0], "a composable modifier parameter needs the default Modifier");
+		return null;
+	}
+	const nullable = typeTokens.at(-1)?.text === "?";
+	if (fallback !== void 0 && !(nullable && fallback === "null")) {
+		fail(file, part[0], `composable parameter ${name} may only default to null`);
+	}
+	const optional = fallback !== void 0;
+	const callback = callbackProp(file, name, typeTokens, optional, "kotlin", named);
+	if (callback) return callback;
+	const resolved = tsType(file, typeTokens, "kotlin", named);
+	return {
+		name,
+		type: resolved.text,
+		nativeType,
+		optional,
+		callback: null,
+		wire: resolved.wire ?? void 0
+	};
+}
+const PLAIN_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"MainActor",
+	"available",
+	"objc",
+	"nonobjc",
+	"preconcurrency"
+]);
+function storedProperty(file, list, i, previous, end, owner) {
+	const at = list[i];
+	const own = list.slice(declarationStart(list, previous, i), i).map((token) => token.text);
+	const propName = list[i + 1]?.text ?? "";
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(propName)) fail(file, list[i], `${owner} has a property without a simple name`);
+	let stop = i + 2;
+	let depth = 0;
+	while (stop < end) {
+		const value = list[stop].text;
+		if (depth === 0 && (value === "=" || value === "{" || value === ";" || list[stop].line !== list[stop - 1].line)) break;
+		if (value === "(" || value === "[" || value === "<") depth++;
+		if (value === ")" || value === "]" || value === ">") depth--;
+		stop++;
+	}
+	const typeTokens = list[i + 2]?.text === ":" ? list.slice(i + 3, stop) : [];
+	const valued = list[stop]?.text === "=";
+	let next = stop;
+	if (valued) {
+		const valueLine = list[stop].line;
+		while (next < end && list[next].line === valueLine && list[next].text !== "{") next++;
+	}
+	const block = list[next]?.text === "{";
+	const computed = block && !valued && !["willSet", "didSet"].includes(list[next + 1]?.text);
+	const resume = block ? close(file, list, next, "{", "}") + 1 : next;
+	return {
+		at,
+		own,
+		propName,
+		typeTokens,
+		valued,
+		stop,
+		computed,
+		resume
+	};
+}
+function swiftView(file, list, keyword, floor, body, end, named) {
+	const modifiers = list.slice(declarationStart(list, floor, keyword), keyword).map((token) => token.text);
+	if (list[keyword].text !== "struct" || !modifiers.includes("public")) return null;
+	if (!list.slice(keyword + 2, body).some((token) => token.text === "View")) return null;
+	const name = list[keyword + 1].text;
+	if (!/^[A-Z][A-Za-z0-9_]*$/.test(name)) fail(file, list[keyword], "an imported view needs a capitalized name");
+	if (list[keyword + 2]?.text === "<") fail(file, list[keyword], `generic view ${name} is unsupported`);
+	const props = [];
+	let i = body + 1;
+	let previous = i;
+	while (i < end) {
+		const text = list[i].text;
+		if (text === "{") {
+			i = close(file, list, i, "{", "}") + 1;
+			previous = i;
+			continue;
+		}
+		if (text === "init" && list[i + 1]?.text === "(" && list[i - 1]?.text !== ".") {
+			fail(file, list[i], `view ${name} is imported through its memberwise initializer; remove init(...)`);
+		}
+		if (text !== "let" && text !== "var") {
+			i++;
+			continue;
+		}
+		const property = storedProperty(file, list, i, previous, end, `view ${name}`);
+		const { at, own, propName, typeTokens, valued, stop } = property;
+		i = property.resume;
+		previous = i;
+		const wrapper = own.findIndex((value, index) => own[index - 1] === "@" && !PLAIN_ATTRIBUTES.has(value));
+		if (property.computed || own.includes("static")) continue;
+		if (wrapper >= 0) {
+			if (valued || own[wrapper + 1] === "(") continue;
+			fail(file, at, `@${own[wrapper]} ${propName} in view ${name} needs a value; pass a plain value and a callback instead`);
+		}
+		if (own.includes("private") || own.includes("fileprivate")) {
+			if (valued) continue;
+			fail(file, at, `private ${propName} in view ${name} needs a value, or the view cannot be built from javascript`);
+		}
+		if (valued && text === "let") continue;
+		if (typeTokens.length === 0) fail(file, at, `view prop ${propName} needs an explicit type`);
+		const nullable = typeTokens.at(-1)?.text === "?";
+		if (valued && !(nullable && list[stop + 1]?.text === "nil" && list[stop + 2]?.line !== list[stop + 1].line)) {
+			fail(file, list[stop], `view prop ${propName} may only default to nil`);
+		}
+		const callback = callbackProp(file, propName, typeTokens, nullable, "swift", named);
+		if (callback) {
+			props.push(callback);
+		} else {
+			const resolved = tsType(file, typeTokens, "swift", named);
+			props.push({
+				name: propName,
+				type: resolved.text,
+				nativeType: typeTokens.map((token) => token.text).join(""),
+				optional: nullable,
+				callback: null,
+				wire: resolved.wire ?? void 0
+			});
+		}
+	}
+	return {
+		name,
+		props
+	};
+}
+function collectDataClass(file, list, keyword, name, token, generic, packageName) {
+	const modifiers = list.slice(declarationStart(list, 0, keyword - 1), keyword).map((entry) => entry.text);
+	let problem = null;
+	if (modifiers.includes("private")) {
+		problem = `data class ${name} must be public to cross the boundary`;
+	}
+	let scan = keyword + 2;
+	if (list[scan]?.text === "<") scan = close(file, list, scan, "<", ">") + 1;
+	while ([
+		"private",
+		"protected",
+		"public",
+		"internal",
+		"constructor"
+	].includes(list[scan]?.text)) scan++;
+	const params = [];
+	if (list[scan]?.text === "(") {
+		const closing = close(file, list, scan, "(", ")");
+		for (const part of split(list.slice(scan + 1, closing), ",")) {
+			if (part.length > 0) params.push(part);
+		}
+	} else {
+		return null;
+	}
+	if (list.slice(keyword + 2, scan).some((entry) => entry.text === "private" || entry.text === "protected")) {
+		problem = problem ?? `data class ${name} must be public to cross the boundary`;
+	}
+	return {
+		name,
+		token,
+		generic,
+		codable: true,
+		problem,
+		body: [],
+		params,
+		packageName
+	};
+}
+function collectSwiftEnum(file, body, name, token, generic, header) {
+	const backing = header.some((entry) => entry.text === "String") ? "string" : header.some((entry) => entry.text === "Int") ? "number" : null;
+	if (generic) {
+		return {
+			name,
+			token,
+			generic,
+			usable: false,
+			problem: `generic enum ${name} is unsupported`,
+			backing: "string",
+			cases: []
+		};
+	}
+	if (!backing) {
+		return {
+			name,
+			token,
+			generic,
+			usable: false,
+			problem: `enum ${name} needs a String or Int backing to cross the boundary`,
+			backing: "string",
+			cases: []
+		};
+	}
+	const inherits = header.map((entry) => entry.text);
+	if (!inherits.includes("Codable") && !(inherits.includes("Decodable") && inherits.includes("Encodable"))) {
+		return {
+			name,
+			token,
+			generic,
+			usable: false,
+			problem: `enum ${name} must conform to Codable to cross the boundary`,
+			backing,
+			cases: []
+		};
+	}
+	const memberStarters = /* @__PURE__ */ new Set([
+		"func",
+		"var",
+		"let",
+		"init",
+		"deinit",
+		"subscript",
+		"static",
+		"public",
+		"private",
+		"fileprivate",
+		"internal",
+		"open",
+		"final",
+		"mutating",
+		"nonmutating",
+		"override",
+		"lazy",
+		"weak",
+		"unowned",
+		"required",
+		"convenience",
+		"dynamic",
+		"indirect",
+		"typealias",
+		"import"
+	]);
+	const cases = [];
+	let problem = null;
+	let counter = 0;
+	let i = 0;
+	let depth = 0;
+	while (i < body.length) {
+		if (body[i].text === "{") {
+			depth++;
+			i++;
+			continue;
+		}
+		if (body[i].text === "}") {
+			depth--;
+			i++;
+			continue;
+		}
+		if (depth !== 0 || body[i].text !== "case") {
+			i++;
+			continue;
+		}
+		let stop = i + 1;
+		let inner = 0;
+		while (stop < body.length) {
+			const value = body[stop].text;
+			if (inner === 0 && (value === ";" || value === "case" || memberStarters.has(value))) break;
+			if (value === "(" || value === "[" || value === "<") inner++;
+			if (value === ")" || value === "]" || value === ">") inner--;
+			stop++;
+			if (inner < 0) break;
+		}
+		for (const item of split(body.slice(i + 1, stop), ",")) {
+			const itemName = item[0]?.text ?? "";
+			if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(itemName)) continue;
+			if (item.some((entry) => entry.text === "(")) {
+				problem = problem ?? `enum ${name} has associated values, which cannot cross the boundary`;
+				continue;
+			}
+			if (item.some((entry) => entry.text === "=")) {
+				problem = problem ?? `enum ${name} has an explicit raw value, which cannot cross the boundary`;
+				continue;
+			}
+			cases.push({
+				name: itemName,
+				value: backing === "string" ? itemName : counter
+			});
+			counter++;
+		}
+		i = stop;
+	}
+	return {
+		name,
+		token,
+		generic,
+		usable: problem === null,
+		problem: problem ?? "",
+		backing,
+		cases
+	};
+}
+function collectKotlinEnum(file, body, name, token) {
+	const cases = [];
+	let i = 0;
+	const stopWords = /* @__PURE__ */ new Set([
+		";",
+		"fun",
+		"val",
+		"var",
+		"init",
+		"companion",
+		"constructor",
+		"object",
+		"inner",
+		"abstract",
+		"open",
+		"override",
+		"lateinit",
+		"const",
+		"public",
+		"private",
+		"protected",
+		"internal"
+	]);
+	while (i < body.length && !stopWords.has(body[i].text)) {
+		if (body[i].text === ",") {
+			i++;
+			continue;
+		}
+		if (body[i].text === "@") {
+			i += 2;
+			if (body[i]?.text === "(") i = close(file, body, i, "(", ")") + 1;
+			continue;
+		}
+		const entry = body[i].text;
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(entry)) break;
+		cases.push({
+			name: entry,
+			value: entry
+		});
+		i++;
+		while (i < body.length && (body[i].text === "(" || body[i].text === "{")) {
+			i = close(file, body, i, body[i].text, body[i].text === "(" ? ")" : "}") + 1;
+		}
+	}
+	return {
+		name,
+		token,
+		generic: false,
+		usable: cases.length > 0,
+		problem: cases.length > 0 ? "" : `enum class ${name} has no entries to cross the boundary`,
+		backing: "string",
+		cases
+	};
+}
+const STRUCT_MEMBER_WORDS = /* @__PURE__ */ new Set([
+	"init",
+	"deinit",
+	"func",
+	"subscript",
+	"struct",
+	"enum",
+	"class",
+	"extension",
+	"object",
+	"static"
+]);
+function swiftStructFields(file, struct, named) {
+	const fields = [];
+	const body = struct.body;
+	const end = body.length;
+	let i = 0;
+	let previous = 0;
+	while (i < end) {
+		const text = body[i].text;
+		if (text === "{") {
+			i = close(file, body, i, "{", "}") + 1;
+			previous = i;
+			continue;
+		}
+		if (STRUCT_MEMBER_WORDS.has(text)) {
+			let scan = i + 1;
+			let angle = 0;
+			let round = 0;
+			while (scan < end) {
+				const value = body[scan].text;
+				if (value === "<") angle++;
+				else if (value === ">") angle--;
+				else if (value === "(") round++;
+				else if (value === ")") round--;
+				else if (value === "{" && angle === 0 && round === 0) break;
+				else if (value === ";" && angle === 0 && round === 0) break;
+				scan++;
+			}
+			i = body[scan]?.text === "{" ? close(file, body, scan, "{", "}") + 1 : scan + 1;
+			previous = i;
+			continue;
+		}
+		if (text !== "let" && text !== "var") {
+			i++;
+			continue;
+		}
+		const property = storedProperty(file, body, i, previous, end, `struct ${struct.name}`);
+		const { at, own, propName, typeTokens, valued } = property;
+		i = property.resume;
+		previous = i;
+		if (property.computed || own.includes("static")) continue;
+		const wrapper = own.findIndex((value, index) => own[index - 1] === "@" && !PLAIN_ATTRIBUTES.has(value));
+		if (wrapper >= 0) {
+			fail(file, at, `@${own[wrapper]} ${propName} in struct ${struct.name} is unsupported; cross a plain value instead`);
+		}
+		if (own.includes("private") || own.includes("fileprivate")) {
+			if (valued) continue;
+			fail(file, at, `private ${propName} in struct ${struct.name} needs a value, or calls cannot supply it`);
+		}
+		if (typeTokens.length === 0) fail(file, at, `struct ${struct.name} field ${propName} needs an explicit type`);
+		const resolved = tsType(file, typeTokens, "swift", named);
+		fields.push({
+			name: propName,
+			type: resolved.text,
+			nativeType: typeTokens.map((token) => token.text).join(""),
+			optional: valued,
+			wire: resolved.wire ?? void 0
+		});
+	}
+	return fields;
+}
+function kotlinStructFields(file, struct, named) {
+	const fields = [];
+	for (const part of struct.params) {
+		const keyword = part.findIndex((token) => token.text === "val" || token.text === "var");
+		if (keyword < 0) fail(file, part[0], `data class ${struct.name} field needs val or var`);
+		if (part.some((token) => token.text === "vararg")) {
+			fail(file, part[0], `data class ${struct.name} field ${part[keyword + 1]?.text ?? ""} is vararg, which cannot cross the boundary`);
+		}
+		const fieldName = part[keyword + 1]?.text ?? "";
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(fieldName)) {
+			fail(file, part[keyword], `data class ${struct.name} has a field without a simple name`);
+		}
+		let colon = -1;
+		let equals = -1;
+		let depth = 0;
+		for (let t = keyword + 2; t < part.length; t++) {
+			const value = part[t].text;
+			if (value === "(" || value === "[" || value === "<") depth++;
+			else if (value === ")" || value === "]" || value === ">") depth--;
+			else if (depth === 0 && value === ":" && colon < 0) colon = t;
+			else if (depth === 0 && value === "=" && equals < 0) equals = t;
+		}
+		if (colon < 0) fail(file, part[keyword], `data class ${struct.name} field ${fieldName} needs an explicit type`);
+		const typeTokens = part.slice(colon + 1, equals < 0 ? part.length : equals);
+		const fallback = equals < 0 ? void 0 : part.slice(equals + 1).map((token) => token.text).join("");
+		const resolved = tsType(file, typeTokens, "kotlin", named);
+		fields.push({
+			name: fieldName,
+			type: resolved.text,
+			nativeType: typeTokens.map((token) => token.text).join(""),
+			optional: equals >= 0,
+			wire: resolved.wire ?? void 0,
+			fallback
+		});
+	}
+	return fields;
+}
+function finalizeNamedTypes(file, language, named, structs, enums, modules, views) {
+	const reached = /* @__PURE__ */ new Set();
+	const queue = [];
+	const visitWire = (wire) => {
+		if (!wire) return;
+		if (wire.kind === "struct" || wire.kind === "enum") {
+			if (!reached.has(wire.name)) {
+				reached.add(wire.name);
+				if (wire.kind === "struct") queue.push(wire.name);
+			}
+		} else if (wire.kind === "array") visitWire(wire.element);
+		else if (wire.kind === "map") visitWire(wire.value);
+		else if (wire.kind === "nullable") visitWire(wire.inner);
+	};
+	for (const module of modules) {
+		for (const method of module.methods) {
+			for (const param of method.parameters) visitWire(param.wire);
+			visitWire(method.resultWire);
+			for (const arg of method.subscription?.payload ?? []) visitWire(arg.wire);
+		}
+	}
+	for (const view of views) {
+		for (const prop of view.props) {
+			visitWire(prop.wire);
+			for (const arg of prop.callback ?? []) visitWire(arg.wire);
+		}
+	}
+	const byName = new Map(structs.map((entry) => [entry.name, entry]));
+	const parsed = /* @__PURE__ */ new Map();
+	while (queue.length > 0) {
+		const name = queue.pop();
+		if (parsed.has(name)) continue;
+		const decl = byName.get(name);
+		if (!decl) continue;
+		const fields = language === "swift" ? swiftStructFields(file, decl, named) : kotlinStructFields(file, decl, named);
+		parsed.set(name, fields);
+		for (const field of fields) visitWire(field.wire);
+	}
+	return {
+		structs: structs.filter((entry) => reached.has(entry.name)).map((entry) => ({
+			name: entry.name,
+			fields: parsed.get(entry.name) ?? []
+		})),
+		enums: enums.filter((entry) => reached.has(entry.name)).map((entry) => ({
+			name: entry.name,
+			backing: entry.backing,
+			cases: entry.cases
+		}))
+	};
+}
+function collectNamedTypes(file, list, language, packageName) {
+	const structs = [];
+	const enums = [];
+	let depth = 0;
+	let i = 0;
+	while (i < list.length) {
+		const text = list[i].text;
+		if (text === "{") {
+			depth++;
+			i++;
+			continue;
+		}
+		if (text === "}") {
+			depth--;
+			i++;
+			continue;
+		}
+		if (depth !== 0) {
+			i++;
+			continue;
+		}
+		const isSwiftStruct = language === "swift" && text === "struct";
+		const isSwiftEnum = language === "swift" && text === "enum";
+		const isDataClass = language === "kotlin" && text === "class" && list[i - 1]?.text === "data";
+		const isKotlinEnum = language === "kotlin" && text === "class" && list[i - 1]?.text === "enum";
+		if (!isSwiftStruct && !isSwiftEnum && !isDataClass && !isKotlinEnum) {
+			i++;
+			continue;
+		}
+		const name = list[i + 1]?.text;
+		if (!name || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+			i++;
+			continue;
+		}
+		const token = list[i + 1];
+		const generic = list[i + 2]?.text === "<";
+		if (isDataClass) {
+			const dataClass = collectDataClass(file, list, i, name, token, generic, packageName);
+			let scan = i + 2;
+			if (list[scan]?.text === "<") scan = close(file, list, scan, "<", ">") + 1;
+			while ([
+				"private",
+				"protected",
+				"public",
+				"internal",
+				"constructor"
+			].includes(list[scan]?.text)) scan++;
+			i = list[scan]?.text === "(" ? close(file, list, scan, "(", ")") + 1 : i + 2;
+			if (dataClass) structs.push(dataClass);
+			continue;
+		}
+		let body = i + 2;
+		let angle = 0;
+		let round = 0;
+		while (body < list.length) {
+			const value = list[body].text;
+			if (value === "<") angle++;
+			else if (value === ">") angle--;
+			else if (value === "(") round++;
+			else if (value === ")") round--;
+			else if (value === "{" && angle === 0 && round === 0) break;
+			body++;
+		}
+		if (body >= list.length) {
+			i++;
+			continue;
+		}
+		const end = close(file, list, body, "{", "}");
+		const header = list.slice(i + 2, body);
+		if (isSwiftStruct) {
+			const inherits = header.map((entry) => entry.text);
+			const modifiers = list.slice(declarationStart(list, 0, i), i).map((entry) => entry.text);
+			structs.push({
+				name,
+				token,
+				generic,
+				codable: inherits.includes("Codable") || inherits.includes("Decodable") && inherits.includes("Encodable"),
+				problem: modifiers.includes("private") || modifiers.includes("fileprivate") ? `struct ${name} is private to its file and cannot cross the boundary` : null,
+				body: list.slice(body + 1, end),
+				params: [],
+				packageName: void 0
+			});
+		} else {
+			enums.push(language === "swift" ? collectSwiftEnum(file, list.slice(body + 1, end), name, token, generic, header) : collectKotlinEnum(file, list.slice(body + 1, end), name, token));
+		}
+		i = end + 1;
+	}
+	return {
+		structs,
+		enums,
+		names: {
+			structs: new Map(structs.map((entry) => [entry.name, {
+				codable: entry.codable,
+				generic: entry.generic,
+				problem: entry.problem
+			}])),
+			enums: new Map(enums.map((entry) => [entry.name, {
+				usable: entry.usable,
+				problem: entry.problem
+			}]))
+		}
+	};
+}
+function composableView(file, list, keyword, floor, named) {
+	const modifiers = list.slice(declarationStart(list, floor, keyword), keyword).map((token) => token.text);
+	if (!modifiers.some((value, index) => value === "@" && modifiers[index + 1] === "Composable")) return null;
+	if (modifiers.includes("private") || modifiers.includes("internal")) return null;
+	const name = list[keyword + 1]?.text;
+	if (!name || !/^[A-Z][A-Za-z0-9_]*$/.test(name)) fail(file, list[keyword], "an imported composable needs a capitalized name");
+	if (list[keyword + 2]?.text !== "(") fail(file, list[keyword], "generic or extension composables are unsupported");
+	const closing = close(file, list, keyword + 2, "(", ")");
+	if (list[closing + 1]?.text === ":") fail(file, list[closing + 1], `composable ${name} must return Unit`);
+	const inner = list.slice(keyword + 3, closing);
+	const props = inner.length === 0 ? [] : split(inner, ",").flatMap((part) => {
+		if (part.length === 0) return [];
+		const prop = viewProp(file, part, named);
+		return prop ? [prop] : [];
+	});
+	return {
+		name,
+		props
+	};
+}
+function nativeSourceContract(file, source) {
+	const language = file.endsWith(".swift") ? "swift" : file.endsWith(".kt") ? "kotlin" : void 0;
+	if (!language) throw new Error(`${file}: expected a .swift or .kt source file`);
+	const list = tokens(file, source);
+	const packageToken = language === "kotlin" ? list.findIndex((token) => token.text === "package") : -1;
+	const packageName = packageToken < 0 ? void 0 : list.slice(packageToken + 1).filter((token) => token.line === list[packageToken].line).map((token) => token.text).join("");
+	if (packageName && !/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(packageName)) {
+		fail(file, list[packageToken], `unsupported kotlin package ${packageName}`);
+	}
+	const collected = collectNamedTypes(file, list, language, packageName);
+	const named = collected.names;
+	const modules = [];
+	const views = [];
+	let defaultView = false;
+	let i = 0;
+	let previous = 0;
+	while (i < list.length) {
+		const kind = list[i].text;
+		const declaration2 = language === "swift" ? kind === "class" || kind === "struct" : kind === "object";
+		if (language === "kotlin" && kind === "fun") {
+			const view2 = composableView(file, list, i, previous, named);
+			if (view2) {
+				if (views.some((other) => other.name === view2.name)) fail(file, list[i], `overloaded composable ${view2.name} is unsupported`);
+				views.push(view2);
+			}
+			i++;
+			continue;
+		}
+		if (!declaration2) {
+			if (kind === "{") {
+				i = close(file, list, i, "{", "}") + 1;
+				previous = i;
+			} else i++;
+			continue;
+		}
+		const name = list[i + 1]?.text;
+		if (!name) fail(file, list[i], "native type has no name");
+		let body = i + 2;
+		while (body < list.length && list[body].text !== "{") body++;
+		if (body === list.length) fail(file, list[i], "native type has no body");
+		const end = close(file, list, body, "{", "}");
+		const prefix = list.slice(previous, i).map((token) => token.text);
+		if (language === "swift" && prefix.some((value, index) => value === "@" && prefix[index + 1] === "main")) {
+			defaultView = true;
+		}
+		const inherits = list.slice(i + 2, body).map((token) => token.text);
+		if (inherits.includes(language === "swift" ? "PeachModule" : "OneModule")) {
+			modules.push({
+				name,
+				methods: methods(file, list, body, end, language, named)
+			});
+		}
+		const view = language === "swift" ? swiftView(file, list, i, previous, body, end, named) : null;
+		if (view) views.push(view);
+		i = end + 1;
+		previous = i;
+	}
+	const finalized = finalizeNamedTypes(file, language, named, collected.structs, collected.enums, modules, views);
+	const structs = finalized.structs;
+	const enums = finalized.enums;
+	const canonical = JSON.stringify({
+		language,
+		packageName,
+		modules,
+		views,
+		structs,
+		enums,
+		defaultView
+	});
+	const hash = createHash("sha256").update(canonical).digest("hex");
+	const declarations = structs.map((struct) => `export interface ${struct.name} {${struct.fields.map((field) => ` ${field.name}${field.optional ? "?" : ""}: ${field.type};`).join("")} }`);
+	declarations.push(...enums.map((type) => `export type ${type.name} = ${type.cases.map((entry) => typeof entry.value === "string" ? JSON.stringify(entry.value) : String(entry.value)).join(" | ")}`));
+	declarations.push(...modules.map((module) => [
+		`export declare const ${module.name}: {`,
+		...module.methods.map((method) => method.subscription ? `  ${method.name}(listener: (${method.subscription.payload.map((arg, index) => `value${index}: ${arg.type}`).join(", ")}) => void): () => void` : `  ${method.name}(${method.parameters.map((param) => `${param.name}: ${param.type}`).join(", ")}): Promise<${method.result}>`),
+		"}"
+	].join("\n")));
+	declarations.push(...views.map((view) => `export declare function ${view.name}(props: {${view.props.map((prop) => ` ${prop.name}${prop.optional ? "?" : ""}: ${prop.type}`).join(";")} }): ReactElement`));
+	if (defaultView) {
+		declarations.unshift("export default function SwiftPackage(props: Record<string, unknown>): ReactElement");
+	}
+	if (defaultView || views.length > 0) declarations.unshift("import type { ReactElement } from 'react'");
+	const declaration = `${GENERATED_HEADER}${declarations.join("\n\n")}
+`;
+	return {
+		language,
+		packageName,
+		modules,
+		views,
+		structs,
+		enums,
+		defaultView,
+		hash,
+		declaration
+	};
+}
+function kotlinSourceId(root, file) {
+	const path = relative(root, file).replaceAll("\\", "/");
+	if (path.startsWith("../") || !path.endsWith(".kt")) {
+		throw new Error(`${file} is not a kotlin source under ${root}`);
+	}
+	return `K_${createHash("sha256").update(path).digest("hex").slice(0, 16)}`;
+}
+function swiftPodManifest(file, source) {
+	const list = tokens(file, source);
+	const modes = /* @__PURE__ */ new Set();
+	let mainActorIsolation = false;
+	for (let i = 0; i < list.length; i++) {
+		if (list[i].text === "." && list[i + 1]?.text === "package" && list[i + 2]?.text === "(") {
+			fail(file, list[i], "SwiftPM package dependencies are unsupported by One prebuild");
+		}
+		if (list[i].text === "." && list[i + 1]?.text === "swiftLanguageMode" && list[i + 2]?.text === "(") {
+			const mode = /^v(\d+)$/.exec(list[i + 4]?.text ?? "");
+			if (list[i + 3]?.text !== "." || !mode) fail(file, list[i], "unsupported swift language mode");
+			modes.add(Number(mode[1]));
+		}
+		if (list[i].text === "swiftLanguageModes" && list[i + 1]?.text === ":") {
+			const opening = i + 2;
+			if (list[opening]?.text !== "[") fail(file, list[i], "unsupported swift language modes");
+			const ending = close(file, list, opening, "[", "]");
+			for (let j = opening; j < ending; j++) {
+				if (list[j].text === "." && /^v\d+$/.test(list[j + 1]?.text ?? "")) {
+					modes.add(Number(list[j + 1].text.slice(1)));
+				}
+			}
+		}
+		if (list[i].text === "." && list[i + 1]?.text === "defaultIsolation" && list[i + 2]?.text === "(") {
+			if (list[i + 3]?.text !== "MainActor") fail(file, list[i], "unsupported swift default isolation");
+			mainActorIsolation = true;
+		}
+	}
+	if (modes.size > 1) throw new Error(`${file}: One pod needs one swift language mode; found ${[...modes].join(", ")}`);
+	const languageMode = modes.values().next().value ?? 5;
+	if (languageMode !== 5 && languageMode !== 6) {
+		throw new Error(`${file}: unsupported swift language mode v${languageMode}`);
+	}
+	return {
+		languageMode,
+		mainActorIsolation
+	};
+}
+function writeNativeSourceDeclaration(file) {
+	const contract = nativeSourceContract(file, readFileSync(file, "utf8"));
+	const extension = contract.language === "swift" ? ".swift" : ".kt";
+	const declaration = join(dirname(file), `${basename(file, extension)}.d${extension}.ts`);
+	if (contract.modules.length === 0 && contract.views.length === 0 && !contract.defaultView) {
+		if (existsSync(declaration) && readFileSync(declaration, "utf8").startsWith(GENERATED_HEADER)) {
+			rmSync(declaration, { force: true });
+		}
+		return contract;
+	}
+	writeGeneratedFile(declaration, contract.declaration);
+	return contract;
+}
+function writeNativeSourceDeclarations(root) {
+	const contracts = [];
+	const visit = (dir) => {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			if (entry.name.startsWith(".") || SKIP_SOURCE_DIRS.has(entry.name)) continue;
+			const file = join(dir, entry.name);
+			if (entry.isDirectory()) visit(file);
+			else if (entry.isFile() && /\.(swift|kt)$/.test(entry.name) && entry.name !== "Package.swift") {
+				contracts.push(writeNativeSourceDeclaration(file));
+			}
+		}
+	};
+	visit(root);
+	for (const packageDir of swiftPackageDirectories(root).values()) {
+		writeSwiftPackageArtifacts(packageDir);
+	}
+	return contracts;
+}
+function writeSwiftPackageArtifacts(packageDir) {
+	const contracts = [];
+	const files = {};
+	const modules = {};
+	const views = {};
+	const defaultViewFiles = [];
+	const visit = (dir) => {
+		const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") || SKIP_SOURCE_DIRS.has(entry.name)) continue;
+			const file = join(dir, entry.name);
+			if (entry.isDirectory()) visit(file);
+			else if (entry.isFile() && entry.name.endsWith(".swift") && entry.name !== "Package.swift") {
+				const contract = writeNativeSourceDeclaration(file);
+				contracts.push(contract);
+				const name = relative(packageDir, file).replaceAll("\\", "/");
+				files[name] = [...contract.modules, ...contract.views].map((entry2) => entry2.name);
+				for (const module of contract.modules) modules[module.name] = module.methods.map((method) => method.name);
+				for (const view of contract.views) views[view.name] = view.props.map((prop) => prop.name);
+				if (contract.defaultView) defaultViewFiles.push(name);
+			}
+		}
+	};
+	visit(packageDir);
+	const packageId = swiftPackageId(packageDir);
+	const rendered = renderSwiftSourceGlue(packageId, contracts);
+	const descriptor = join(packageDir, ".one-native-source.json");
+	const glue = join(packageDir, ".one-native-source.swift.txt");
+	const exported = contracts.some((contract) => contract.modules.length > 0 || contract.views.length > 0);
+	if (exported) {
+		const json = `${JSON.stringify({
+			generatedBy: "one typegen",
+			packageId,
+			hash: rendered.hash,
+			files,
+			modules,
+			views,
+			defaultViewFiles
+		}, null, 2)}
+`;
+		writeGeneratedFile(descriptor, json);
+		writeGeneratedFile(glue, rendered.source);
+	} else if (existsSync(descriptor) && readFileSync(descriptor, "utf8").includes("\"generatedBy\": \"one typegen\"")) {
+		rmSync(descriptor, { force: true });
+		rmSync(glue, { force: true });
+	}
+	return {
+		packageId,
+		hash: rendered.hash,
+		files,
+		modules,
+		views,
+		defaultViewFiles,
+		contracts,
+		glue: exported ? rendered.source : null
+	};
+}
+function renderSwiftSourceGlue(packageId, contracts) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(packageId)) {
+		throw new Error(`invalid swift package id ${packageId}`);
+	}
+	for (const contract of contracts) {
+		if (contract.language !== "swift") throw new Error("swift glue received a kotlin contract");
+	}
+	const modules = contracts.flatMap((contract) => contract.modules);
+	const views = contracts.flatMap((contract) => contract.views);
+	const names = /* @__PURE__ */ new Set();
+	for (const { name } of [...modules, ...views]) {
+		if (names.has(name)) throw new Error(`swift package ${packageId} declares ${name} twice`);
+		names.add(name);
+	}
+	const hash = createHash("sha256").update(JSON.stringify({
+		packageId,
+		modules,
+		views
+	})).digest("hex");
+	const hasMain = contracts.some((contract) => contract.defaultView);
+	const bodyName = `OneNativeSourceBody_${packageId}`;
+	const className = `OneNativeSource_${packageId}`;
+	const viewsName = `OneNativeSourceViews_${packageId}`;
+	const renderCase = (method, module) => {
+		const subscription = method.subscription;
+		if (subscription) {
+			const channel = `OneNativeSource.${packageId}.${module.name}.${method.name}`;
+			const closureArgs = subscription.payload.map((arg, index) => `a${index}: ${arg.nativeType}`).join(", ");
+			const emitArgs = subscription.payload.map((_, index) => `a${index}`).join(", ");
+			const prefix2 = `${method.throws ? "try " : ""}${method.async ? "await " : ""}`;
+			return [
+				`      case ${JSON.stringify(method.name)}:`,
+				`        guard values.isEmpty else { throw NSError(domain: "OneNativeSource", code: 2, userInfo: [NSLocalizedDescriptionKey: "${packageId}.${module.name}.${method.name} subscribes; it takes no arguments"]) }`,
+				`        let channel = ${JSON.stringify(channel)}`,
+				`        ${prefix2}${module.name}Instance.${method.name}({ ${closureArgs ? `(${closureArgs}) in ` : ""}postEvent(channel, args([${emitArgs}])) })`,
+				"        return \"null\""
+			];
+		}
+		const lines = [`      case ${JSON.stringify(method.name)}:`, `        guard values.count == ${method.parameters.length} else { throw NSError(domain: "OneNativeSource", code: 2, userInfo: [NSLocalizedDescriptionKey: "${packageId}.${module.name}.${method.name} expects ${method.parameters.length} arguments"]) }`];
+		method.parameters.forEach((parameter, index) => {
+			lines.push(`        let arg${index} = try decode(values[${index}], as: ${parameter.nativeType}.self)`);
+		});
+		const argumentsText = method.parameters.map((parameter, index) => `${parameter.label === "_" ? "" : `${parameter.label}: `}arg${index}`).join(", ");
+		const prefix = `${method.throws ? "try " : ""}${method.async ? "await " : ""}`;
+		const call = `${module.name}Instance.${method.name}(${argumentsText})`;
+		if (method.result === "void") {
+			lines.push(`        ${prefix}${call}`, "        return \"null\"");
+		} else {
+			lines.push(`        let result = ${prefix}${call}`);
+			if (method.nativeResult === "Int") {
+				lines.push("        guard abs(Double(result)) <= 9_007_199_254_740_991 else { throw NSError(domain: \"OneNativeSource\", code: 2, userInfo: [NSLocalizedDescriptionKey: \"result exceeds the JavaScript safe integer range\"]) }");
+			}
+			lines.push("        return try encode(result)");
+		}
+		return lines;
+	};
+	const notLinked = "    throw NSError(domain: \"OneNativeSource\", code: 1, userInfo: [NSLocalizedDescriptionKey: \"native module \\(module) is not linked; rebuild the app\"])";
+	const renderCall = () => modules.length === 0 ? [
+		"  static func call(_ module: String, _ method: String, _ argsJson: String) async throws -> String {",
+		notLinked,
+		"  }"
+	] : [
+		"  static func call(_ module: String, _ method: String, _ argsJson: String) async throws -> String {",
+		"    guard let values = try JSONSerialization.jsonObject(with: Data(argsJson.utf8)) as? [Any] else {",
+		"      throw NSError(domain: \"OneNativeSource\", code: 2, userInfo: [NSLocalizedDescriptionKey: \"arguments must be a JSON array\"])",
+		"    }",
+		"    switch module {",
+		...modules.flatMap((module) => [
+			`    case ${JSON.stringify(`${packageId}.${module.name}`)}:`,
+			"      switch method {",
+			...module.methods.flatMap((method) => renderCase(method, module)),
+			"      default: throw NSError(domain: \"OneNativeSource\", code: 1, userInfo: [NSLocalizedDescriptionKey: \"native method \\(module).\\(method) is not linked; rebuild the app\"])",
+			"      }"
+		]),
+		"    default:",
+		`  ${notLinked}`,
+		"    }",
+		"  }"
+	];
+	const renderViews = () => [
+		"  private static func missing(_ path: String) throws -> Any {",
+		"    throw NSError(domain: \"OneNativeSource\", code: 2, userInfo: [NSLocalizedDescriptionKey: \"\\(path): required\"])",
+		"  }",
+		"  static func view(_ name: String, _ propsJson: String, _ emit: @escaping (String, String) -> Void) throws -> AnyView {",
+		"    guard let props = try JSONSerialization.jsonObject(with: Data(propsJson.utf8)) as? [String: Any] else {",
+		"      throw NSError(domain: \"OneNativeSource\", code: 2, userInfo: [NSLocalizedDescriptionKey: \"props must be a JSON object\"])",
+		"    }",
+		"    switch name {",
+		...views.flatMap((view) => [
+			`    case ${JSON.stringify(view.name)}:`,
+			`      return AnyView(${view.name}(`,
+			...view.props.map((prop, index) => {
+				const comma = index === view.props.length - 1 ? "" : ",";
+				const key = JSON.stringify(prop.name);
+				if (prop.callback) {
+					const params = prop.callback.map((arg, n) => `a${n}: ${arg.nativeType}`).join(", ");
+					const lambda = `{ (${params}) -> Void in emit(${key}, args([${prop.callback.map((_, n) => `a${n}`).join(", ")}])) }`;
+					return `        ${prop.name}: ${prop.optional ? `(props[${key}] as? Bool) == true ? ${lambda} : nil` : lambda}${comma}`;
+				}
+				const input = prop.optional ? `props[${key}] ?? NSNull()` : `props[${key}] ?? missing(${JSON.stringify(`props.${prop.name}`)})`;
+				return `        ${prop.name}: try decode(${input}, as: ${prop.nativeType}.self)${comma}`;
+			}),
+			"      ))"
+		]),
+		"    default: throw NSError(domain: \"OneNativeSource\", code: 1, userInfo: [NSLocalizedDescriptionKey: \"swift view \\(name) is not linked; rebuild the app\"])",
+		"    }",
+		"  }"
+	];
+	const source = [
+		"import Foundation",
+		"import SwiftUI",
+		"",
+		`@MainActor public enum ${bodyName} {`,
+		`  public static let hash = ${JSON.stringify(hash)}`,
+		"#if os(WASI)",
+		"  private struct Request: Decodable { let module: String; let method: String; let argsJson: String; let contractHash: String }",
+		"  private struct Reply: Encodable { let ok: Bool; let value: String?; let error: String?; let pending: Int32? }",
+		"  private static var output: [UInt8] = []",
+		"  private static var finished: [Int32: Reply] = [:]",
+		"  private static var nextCall: Int32 = 0",
+		"  // peach runs tasks inline, so a call finishes before its task launch returns",
+		"  // unless it waits on the clock; then it answers pending and the host polls",
+		"  // it after running the timers.",
+		"  static func callWasm(_ payload: UnsafePointer<UInt8>?, _ length: Int32) -> UnsafeMutablePointer<UInt8>? {",
+		"    let id = nextCall",
+		"    nextCall &+= 1",
+		"    do {",
+		"      guard let payload, length >= 0 else { throw NSError(domain: \"OneNativeSource\", code: 2, userInfo: [NSLocalizedDescriptionKey: \"missing call payload\"]) }",
+		"      let request = try JSONDecoder().decode(Request.self, from: Data(bytes: payload, count: Int(length)))",
+		"      guard request.contractHash == hash else { throw NSError(domain: \"OneNativeSource\", code: 4, userInfo: [NSLocalizedDescriptionKey: \"native module \\(request.module) changed; rebuild the app\"]) }",
+		"      Task {",
+		"        do {",
+		"          finished[id] = Reply(ok: true, value: try await call(request.module, request.method, request.argsJson), error: nil, pending: nil)",
+		"        } catch {",
+		"          // the native hosts name the method on everything a call throws",
+		"          finished[id] = Reply(ok: false, value: nil, error: \"\\(request.module).\\(request.method): \\(error.localizedDescription)\", pending: nil)",
+		"        }",
+		"      }",
+		"    } catch {",
+		"      finished[id] = Reply(ok: false, value: nil, error: error.localizedDescription, pending: nil)",
+		"    }",
+		"    return pollWasm(id)",
+		"  }",
+		"  static func pollWasm(_ id: Int32) -> UnsafeMutablePointer<UInt8>? {",
+		"    let reply = finished.removeValue(forKey: id) ?? Reply(ok: true, value: nil, error: nil, pending: id)",
+		"    let bytes = (try? JSONEncoder().encode(reply)) ?? Data(\"{\\\"ok\\\":false,\\\"error\\\":\\\"encoding failed\\\"}\".utf8)",
+		"    let count = UInt32(bytes.count)",
+		"    output = [UInt8(count & 0xff), UInt8((count >> 8) & 0xff), UInt8((count >> 16) & 0xff), UInt8(count >> 24)] + Array(bytes)",
+		"    return output.withUnsafeMutableBufferPointer { $0.baseAddress }",
+		"  }",
+		"  private struct Event: Encodable { let channel: String; let args: String }",
+		"  private static var pendingEvents: [Event] = []",
+		"  // under wasi there is no javascript runtime, so posted events queue",
+		"  // here and the peach host drains them with peach_poll_events, using",
+		"  // the same length-prefixed framing as pollWasm.",
+		"  static func pollEvents() -> UnsafeMutablePointer<UInt8>? {",
+		"    let events = pendingEvents",
+		"    pendingEvents = []",
+		"    let bytes = (try? JSONEncoder().encode(events)) ?? Data(\"[]\".utf8)",
+		"    let count = UInt32(bytes.count)",
+		"    output = [UInt8(count & 0xff), UInt8((count >> 8) & 0xff), UInt8((count >> 16) & 0xff), UInt8(count >> 24)] + Array(bytes)",
+		"    return output.withUnsafeMutableBufferPointer { $0.baseAddress }",
+		"  }",
+		"#endif",
+		...modules.map((module) => `  private static let ${module.name}Instance = ${module.name}()`),
+		"  private nonisolated static let isoDate = Date.ISO8601FormatStyle()",
+		"  private nonisolated static let isoDateFractional = Date.ISO8601FormatStyle(includingFractionalSeconds: true)",
+		"  private nonisolated static func decodeDate(_ decoder: Decoder) throws -> Date {",
+		"    let container = try decoder.singleValueContainer()",
+		"    let text = try container.decode(String.self)",
+		"    if let date = (try? isoDateFractional.parse(text)) ?? (try? isoDate.parse(text)) { return date }",
+		"    throw DecodingError.dataCorruptedError(in: container, debugDescription: \"expected ISO date\")",
+		"  }",
+		"  private static func decode<T: Decodable>(_ value: Any, as type: T.Type) throws -> T {",
+		"    let data = try JSONSerialization.data(withJSONObject: value, options: [.fragmentsAllowed])",
+		"    let decoder = JSONDecoder()",
+		"    decoder.dateDecodingStrategy = .custom { try decodeDate($0) }",
+		"    decoder.dataDecodingStrategy = .base64",
+		"    return try decoder.decode(T.self, from: data)",
+		"  }",
+		"  private static func encode(_ value: any Encodable) throws -> String {",
+		"    let encoder = JSONEncoder()",
+		"    encoder.dateEncodingStrategy = .iso8601",
+		"    encoder.dataEncodingStrategy = .base64",
+		"    return String(decoding: try encoder.encode(value), as: UTF8.self)",
+		"  }",
+		"  private static func encodeAny(_ value: any Encodable) -> String {",
+		"    (try? encode(value)) ?? \"null\"",
+		"  }",
+		"  // subscribe cases and view callbacks both encode callback arguments",
+		"  // as a json array, so this helper stays outside the view-only glue.",
+		"  private static func args(_ values: [any Encodable]) -> String {",
+		"    \"[\" + values.map { encodeAny($0) }.joined(separator: \",\") + \"]\"",
+		"  }",
+		"  // native events post over the one event bridge on device; under wasi",
+		"  // they queue for the peach host, which drains them with peach_poll_events.",
+		"  private static func postEvent(_ channel: String, _ args: String) {",
+		"    #if os(WASI)",
+		"    pendingEvents.append(Event(channel: channel, args: args))",
+		"    #else",
+		"    OneNativeSourceEmitter.send(channel, args)",
+		"    #endif",
+		"  }",
+		...renderCall(),
+		...views.length > 0 ? renderViews() : [],
+		"}",
+		"",
+		"#if os(WASI)",
+		"@_expose(wasm, \"peach_call\")",
+		"@_cdecl(\"peach_call\")",
+		`@MainActor public func peach_call(_ payload: UnsafePointer<UInt8>?, _ length: Int32) -> UnsafeMutablePointer<UInt8>? { ${bodyName}.callWasm(payload, length) }`,
+		"@_expose(wasm, \"peach_call_poll\")",
+		"@_cdecl(\"peach_call_poll\")",
+		`@MainActor public func peach_call_poll(_ id: Int32) -> UnsafeMutablePointer<UInt8>? { ${bodyName}.pollWasm(id) }`,
+		"  // the host drains queued native events with this export, polling it",
+		"  // after running timers like it polls pending calls.",
+		"@_expose(wasm, \"peach_poll_events\")",
+		"@_cdecl(\"peach_poll_events\")",
+		`@MainActor public func peach_poll_events() -> UnsafeMutablePointer<UInt8>? { ${bodyName}.pollEvents() }`,
+		...views.length > 0 ? [
+			"@_expose(wasm, \"peach_register_views\")",
+			"@_cdecl(\"peach_register_views\")",
+			"@MainActor public func peach_register_views() {",
+			"  PeachTypedViews.register { name, contractHash, propsJson, emit in",
+			`    guard contractHash == ${bodyName}.hash else { return AnyView(Text("swift view ${packageId}.\\(name) changed; rebuild the app").foregroundStyle(.red)) }`,
+			`    do { return try ${bodyName}.view(name, propsJson, emit) } catch { return AnyView(Text("\\(name): \\(error.localizedDescription)").foregroundStyle(.red)) }`,
+			"  }",
+			"}"
+		] : [],
+		...!hasMain ? [
+			`@main struct OneNativeSourceMain_${packageId}: App {`,
+			"  var body: some Scene { WindowGroup { EmptyView() } }",
+			"}"
+		] : [],
+		"#endif",
+		"",
+		"#if canImport(ObjectiveC) && !os(WASI)",
+		`@objc(${className}) @MainActor public final class ${className}: NSObject, OneNativeSourceDispatch {`,
+		"  public required override init() {}",
+		`  public var contractHash: String { ${bodyName}.hash }`,
+		`  public func call(_ module: String, _ method: String, _ argsJson: String) async throws -> String { try await ${bodyName}.call(module, method, argsJson) }`,
+		"}",
+		...views.length > 0 ? [
+			`@objc(${viewsName}) @MainActor public final class ${viewsName}: NSObject, OneNativeSourceViewDispatch {`,
+			"  public required override init() {}",
+			`  public var contractHash: String { ${bodyName}.hash }`,
+			`  public func view(_ name: String, _ propsJson: String, _ emit: @escaping (String, String) -> Void) throws -> AnyView { try ${bodyName}.view(name, propsJson, emit) }`,
+			"}"
+		] : [],
+		"#endif",
+		""
+	].join("\n");
+	return {
+		hash,
+		source
+	};
+}
+function renderKotlinSourceGlue(sourceId, contract) {
+	if (contract.language !== "kotlin") throw new Error("kotlin glue received a swift contract");
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(sourceId)) throw new Error(`invalid kotlin source id ${sourceId}`);
+	const hash = createHash("sha256").update(JSON.stringify({
+		sourceId,
+		contract: contract.hash
+	})).digest("hex");
+	const structsByName = new Map(contract.structs.map((entry) => [entry.name, entry]));
+	const enumsByName = new Map(contract.enums.map((entry) => [entry.name, entry]));
+	const qualified = (name) => contract.packageName ? `${contract.packageName}.${name}` : name;
+	const isDateType = (type) => type === "Date" || type === "java.util.Date";
+	const mentions = (type, match) => {
+		let rest = type;
+		while (rest.endsWith("?")) rest = rest.slice(0, -1);
+		if (rest.startsWith("List<") && rest.endsWith(">")) return mentions(rest.slice(5, -1), match);
+		if (rest.startsWith("Map<String,") && rest.endsWith(">")) return mentions(rest.slice(11, -1), match);
+		return match(rest);
+	};
+	const nativeTypes = [
+		...contract.modules.flatMap((module) => module.methods.flatMap((method) => [
+			...method.parameters.map((parameter) => parameter.nativeType),
+			method.nativeResult,
+			...method.subscription?.payload.map((arg) => arg.nativeType) ?? []
+		])),
+		...contract.structs.flatMap((struct) => struct.fields.map((field) => field.nativeType)),
+		...contract.views.flatMap((view) => view.props.flatMap((prop) => [prop.nativeType, ...prop.callback?.map((arg) => arg.nativeType) ?? []]))
+	];
+	const needsEvents = contract.modules.some((module) => module.methods.some((method) => method.subscription));
+	const needsDate = nativeTypes.some((type) => mentions(type, isDateType));
+	const needsData = nativeTypes.some((type) => mentions(type, (leaf) => leaf === "ByteArray"));
+	const value = (type, input, path) => {
+		if (type.endsWith("?")) {
+			return `(${input}).let { raw -> if (raw == null || raw == JSONObject.NULL) null else ${value(type.slice(0, -1), "raw", path)} }`;
+		}
+		if (type === "String") return `readString(${input}, ${path})`;
+		if (type === "Boolean") return `readBoolean(${input}, ${path})`;
+		if (type === "Double") return `readDouble(${input}, ${path})`;
+		if (type === "Float") return `readDouble(${input}, ${path}).toFloat()`;
+		if (type === "Int") return `readInt(${input}, ${path})`;
+		if (type === "Long") return `readLong(${input}, ${path})`;
+		if (isDateType(type)) return `readDate(${input}, ${path})`;
+		if (type === "ByteArray") return `readData(${input}, ${path})`;
+		if (structsByName.has(type)) return `read${type}(${input}, ${path})`;
+		if (enumsByName.has(type)) return `read${type}(${input}, ${path})`;
+		if (type.startsWith("List<") && type.endsWith(">")) {
+			return `readList(${input}, ${path}) { item, itemPath -> ${value(type.slice(5, -1), "item", "itemPath")} }`;
+		}
+		if (type.startsWith("Map<String,") && type.endsWith(">")) {
+			return `readMap(${input}, ${path}) { item, itemPath -> ${value(type.slice(11, -1), "item", "itemPath")} }`;
+		}
+		throw new Error(`unsupported kotlin glue type ${type}`);
+	};
+	const encode = (type, accessor) => {
+		if (type.endsWith("?")) {
+			return `(${accessor}?.let { ${encode(type.slice(0, -1), "it")} } ?: JSONObject.NULL)`;
+		}
+		if (isDateType(type)) return `dateToString(${accessor})`;
+		if (type === "ByteArray") return `android.util.Base64.encodeToString(${accessor}, android.util.Base64.NO_WRAP)`;
+		if (structsByName.has(type)) return `encode${type}(${accessor})`;
+		if (enumsByName.has(type)) return `${accessor}.name`;
+		if (type.startsWith("List<") && type.endsWith(">")) {
+			return `JSONArray().apply { for (item in ${accessor}) put(${encode(type.slice(5, -1), "item")}) }`;
+		}
+		if (type.startsWith("Map<String,") && type.endsWith(">")) {
+			return `JSONObject().apply { for ((key, entry) in ${accessor}) put(key, ${encode(type.slice(11, -1), "entry")}) }`;
+		}
+		return `JSONObject.wrap(${accessor})`;
+	};
+	const structHelpers = contract.structs.flatMap((struct) => [
+		`private fun read${struct.name}(value: Any, path: String): ${qualified(struct.name)} {`,
+		"  val obj = value as? JSONObject ?: error(\"$path: expected object\")",
+		`  return ${qualified(struct.name)}(`,
+		...struct.fields.map((field) => {
+			const fieldPath = `"$path.${field.name}"`;
+			const required = `error("$path.${field.name}: required")`;
+			const input = field.optional ? `(if (obj.has(${JSON.stringify(field.name)})) obj.get(${JSON.stringify(field.name)}) else ${field.fallback ?? required})` : `(obj.opt(${JSON.stringify(field.name)}) ?: ${required})`;
+			return `    ${field.name} = ${value(field.nativeType, input, fieldPath)},`;
+		}),
+		"  )",
+		"}",
+		`private fun encode${struct.name}(value: ${qualified(struct.name)}): JSONObject {`,
+		"  return JSONObject()",
+		...struct.fields.map((field) => `    .put(${JSON.stringify(field.name)}, ${encode(field.nativeType, `value.${field.name}`)})`),
+		"}"
+	]);
+	const enumHelpers = contract.enums.flatMap((entry) => [
+		`private fun read${entry.name}(value: Any, path: String): ${qualified(entry.name)} {`,
+		"  val text = readString(value, path)",
+		`  return try { ${qualified(entry.name)}.valueOf(text) } catch (e: IllegalArgumentException) { error("$path: expected one of ${entry.cases.map((item) => item.name).join(", ")}") }`,
+		"}"
+	]);
+	const source = [
+		"import androidx.annotation.Keep",
+		...contract.views.length === 0 ? [] : ["import androidx.compose.runtime.Composable", "import dev.onejs.one.OneNativeSourceViewDispatch"],
+		"import dev.onejs.one.OneNativeSourceDispatch",
+		...needsEvents ? ["import dev.onejs.one.source.OneNativeSourceEvents"] : [],
+		"import org.json.JSONArray",
+		"import org.json.JSONObject",
+		"",
+		"private fun readString(value: Any, path: String): String = value as? String ?: error(\"$path: expected string\")",
+		"private fun readBoolean(value: Any, path: String): Boolean = value as? Boolean ?: error(\"$path: expected boolean\")",
+		"private fun readDouble(value: Any, path: String): Double {",
+		"  val result = (value as? Number)?.toDouble() ?: error(\"$path: expected number\")",
+		"  if (!result.isFinite()) error(\"$path: expected finite number\")",
+		"  return result",
+		"}",
+		"private fun readInt(value: Any, path: String): Int {",
+		"  val result = readDouble(value, path)",
+		"  if (result % 1.0 != 0.0 || result < Int.MIN_VALUE || result > Int.MAX_VALUE) error(\"$path: expected Int\")",
+		"  return result.toInt()",
+		"}",
+		"private fun readLong(value: Any, path: String): Long {",
+		"  val result = readDouble(value, path)",
+		"  if (result % 1.0 != 0.0 || result < -9007199254740991.0 || result > 9007199254740991.0) error(\"$path: expected safe Long\")",
+		"  return result.toLong()",
+		"}",
+		"private fun <T> readList(value: Any, path: String, read: (Any, String) -> T): List<T> {",
+		"  val array = value as? JSONArray ?: error(\"$path: expected array\")",
+		"  return (0 until array.length()).map { index -> read(array.get(index), \"$path[$index]\") }",
+		"}",
+		"private fun <T> readMap(value: Any, path: String, read: (Any, String) -> T): Map<String, T> {",
+		"  val objectValue = value as? JSONObject ?: error(\"$path: expected object\")",
+		"  return objectValue.keys().asSequence().associateWith { key -> read(objectValue.get(key), \"$path.$key\") }",
+		"}",
+		...needsDate ? [
+			"private fun readDate(value: Any, path: String): java.util.Date {",
+			"  val text = readString(value, path)",
+			`  for (pattern in arrayOf("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", "yyyy-MM-dd'T'HH:mm:ss'Z'")) {`,
+			"    try {",
+			"      return java.text.SimpleDateFormat(pattern, java.util.Locale.US).apply { timeZone = java.util.TimeZone.getTimeZone(\"UTC\"); isLenient = false }.parse(text) ?: error(\"$path: expected date\")",
+			"    } catch (parseError: java.text.ParseException) { }",
+			"  }",
+			"  error(\"$path: expected ISO date\")",
+			"}",
+			"private fun dateToString(value: java.util.Date): String =",
+			`  java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", java.util.Locale.US).apply { timeZone = java.util.TimeZone.getTimeZone("UTC") }.format(value)`
+		] : [],
+		...needsData ? [
+			"private fun readData(value: Any, path: String): ByteArray {",
+			"  try {",
+			"    return android.util.Base64.decode(readString(value, path), android.util.Base64.NO_WRAP)",
+			"  } catch (decodeError: IllegalArgumentException) {",
+			"    error(\"$path: expected base64 data\")",
+			"  }",
+			"}"
+		] : [],
+		...structHelpers,
+		...enumHelpers,
+		"",
+		`@Keep class OneNativeSource_${sourceId}: OneNativeSourceDispatch {`,
+		`  override val contractHash = ${JSON.stringify(hash)}`,
+		"  override suspend fun call(module: String, method: String, argsJson: String): String {",
+		"    val args = JSONArray(argsJson)",
+		"    return when (module) {",
+		...contract.modules.flatMap((module) => [
+			`      ${JSON.stringify(`${sourceId}.${module.name}`)} -> when (method) {`,
+			...module.methods.flatMap((method) => {
+				const subscription = method.subscription;
+				if (subscription) {
+					const channel = `OneNativeSource.${sourceId}.${module.name}.${method.name}`;
+					const closure = subscription.payload.length === 0 ? `{ OneNativeSourceEvents.send(${JSON.stringify(channel)}, JSONArray().toString()) }` : `{ ${subscription.payload.map((_, index) => `a${index}`).join(", ")} -> OneNativeSourceEvents.send(${JSON.stringify(channel)}, JSONArray()${subscription.payload.map((arg, index) => `.put(${encode(arg.nativeType, `a${index}`)})`).join("")}.toString()) }`;
+					return [
+						`        ${JSON.stringify(method.name)} -> {`,
+						`          require(args.length() == 0) { "${sourceId}.${module.name}.${method.name} subscribes; it takes no arguments" }`,
+						`          ${qualified(module.name)}.${method.name}(${closure})`,
+						"          \"null\"",
+						"        }"
+					];
+				}
+				const lines = [`        ${JSON.stringify(method.name)} -> {`, `          require(args.length() == ${method.parameters.length}) { "${sourceId}.${module.name}.${method.name} expects ${method.parameters.length} arguments" }`];
+				method.parameters.forEach((parameter, index) => {
+					lines.push(`          val arg${index} = ${value(parameter.nativeType, `args.get(${index})`, JSON.stringify(`args[${index}]`))}`);
+				});
+				const call = `${qualified(module.name)}.${method.name}(${method.parameters.map((_, index) => `arg${index}`).join(", ")})`;
+				if (method.result === "void") {
+					lines.push(`          ${call}`, "          \"null\"");
+				} else {
+					lines.push(`          val result = ${call}`);
+					if (method.nativeResult === "Long") {
+						lines.push("          require(result >= -9007199254740991L && result <= 9007199254740991L) { \"result exceeds the JavaScript safe integer range\" }");
+					}
+					lines.push(`          JSONArray().put(${encode(method.nativeResult, "result")}).toString().drop(1).dropLast(1)`);
+				}
+				return [...lines, "        }"];
+			}),
+			"        else -> error(\"native method $module.$method is not linked; rebuild the app\")",
+			"      }"
+		]),
+		"      else -> error(\"native module $module is not linked; rebuild the app\")",
+		"    }",
+		"  }",
+		"}",
+		"",
+		...contract.views.length === 0 ? [] : viewGlue(sourceId, contract, hash, value, encode)
+	].join("\n");
+	return {
+		hash,
+		source
+	};
+}
+function viewGlue(sourceId, contract, hash, value, encode) {
+	const qualifier = contract.packageName ? `${contract.packageName}.` : "";
+	return [
+		`@Keep class OneNativeSourceViews_${sourceId}: OneNativeSourceViewDispatch {`,
+		`  override val contractHash = ${JSON.stringify(hash)}`,
+		"  @Composable",
+		"  override fun Content(view: String, propsJson: String, emit: (String, String) -> Unit) {",
+		"    val props = JSONObject(propsJson)",
+		"    when (view) {",
+		...contract.views.flatMap((view) => [
+			`      ${JSON.stringify(view.name)} -> ${qualifier}${view.name}(`,
+			...view.props.map((prop) => {
+				const path = JSON.stringify(`props.${prop.name}`);
+				if (prop.callback) {
+					const args = prop.callback.map((_, index) => `a${index}`);
+					const types = prop.callback.map((arg) => arg.nativeType);
+					const body = `emit(${JSON.stringify(prop.name)}, JSONArray()${args.map((arg, index) => `.put(${encode(types[index], arg)})`).join("")}.toString())`;
+					const lambda = `{ ${args.length > 0 ? `${args.join(", ")} -> ` : ""}${body} }`;
+					return `        ${prop.name} = ${prop.nativeType.endsWith("?") ? `if (props.optBoolean(${JSON.stringify(prop.name)})) (${lambda}) else null` : lambda},`;
+				}
+				const input = prop.optional ? `(props.opt(${JSON.stringify(prop.name)}) ?: JSONObject.NULL)` : `(props.opt(${JSON.stringify(prop.name)}) ?: error(${JSON.stringify(`props.${prop.name}: required`)}))`;
+				return `        ${prop.name} = ${value(prop.nativeType, input, path)},`;
+			}),
+			"      )"
+		]),
+		"      else -> error(\"composable $view is not linked; rebuild the app\")",
+		"    }",
+		"  }",
+		"}",
+		""
+	];
+}
+
+export { kotlinSourceId, nativeSourceContract, renderKotlinSourceGlue, renderSwiftSourceGlue, swiftPodManifest, writeNativeSourceDeclaration, writeNativeSourceDeclarations, writeSwiftPackageArtifacts };
+//# sourceMappingURL=nativeSourceContract.mjs.map