bleam 0.0.11 → 0.0.13

package/dist/ai.cjs

@@ -1,15 +1,14 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
 require('./native-runtime-CsXnXkQn.cjs');
 require('./crypto-CT3VZ7lF.cjs');
-const require_files = require('./files-Bo7h9fik.cjs');
-const require_state = require('./state-Bx0VlTlO.cjs');
-require('./schema-rQ13mrpD.cjs');
+const require_files = require('./files-lMk-CpL_.cjs');
+const require_app_storage = require('./app-storage-D8W4n8ey.cjs');
+const require_schema = require('./schema-B7SLUBLN.cjs');
+const require_state = require('./state-BZYyrE2-.cjs');
 let expo = require("expo");
 expo = require_chunk.__toESM(expo);
 let react = require("react");
 react = require_chunk.__toESM(react);
-let react_native = require("react-native");
-react_native = require_chunk.__toESM(react_native);
 
 //#region src/ai/bonsai.ts
 const internalTextModelCatalog = [
@@ -309,486 +308,344 @@ async function deleteBonsaiTextModel(model, options = {}) {
 }
 
 //#endregion
-//#region src/ai/image-batch.ts
-function batchImageSeeds(count, seed) {
-	if (!Number.isInteger(count) || count < 1 || count > 64) throw new AIError("invalid_message", "Batch count must be an integer from 1 to 64");
-	const first = seed ?? Math.floor(Math.random() * 4294967296);
-	return Array.from({ length: count }, (_, index) => first + index >>> 0);
-}
-
-//#endregion
-//#region src/ai/image-jobs.ts
-var ImageGenerationQueue = class {
-	jobs = /* @__PURE__ */ new Map();
-	pending = [];
-	running;
-	constructor(executor) {
+//#region src/ai/chat-manager.ts
+const missingSnapshot = {
+	chat: null,
+	messages: []
+};
+var ChatManager = class {
+	snapshots = /* @__PURE__ */ new Map();
+	chatListeners = /* @__PURE__ */ new Map();
+	listListeners = /* @__PURE__ */ new Set();
+	controllers = /* @__PURE__ */ new Map();
+	listSnapshot = [];
+	operation = Promise.resolve();
+	ready;
+	constructor(repository, executor) {
+		this.repository = repository;
 		this.executor = executor;
+		this.ready = this.initialize();
 	}
 	setExecutor(executor) {
 		this.executor = executor;
 	}
-	schedule(options) {
-		const id = crypto.randomUUID();
-		let resolve;
-		let reject;
-		const promise = new Promise((onResolve, onReject) => {
-			resolve = onResolve;
-			reject = onReject;
+	async create(input = {}) {
+		await this.ready;
+		return this.mutate(async () => {
+			const chat$1 = await this.repository.create({ title: validTitle(input.title ?? "New Chat") });
+			this.set({
+				chat: chat$1,
+				messages: []
+			});
+			return chat$1;
 		});
-		const record = {
-			snapshot: {
-				id,
-				status: "queued",
-				createdAt: (/* @__PURE__ */ new Date()).toISOString()
-			},
-			options,
-			controller: new AbortController(),
-			listeners: /* @__PURE__ */ new Set(),
-			promise,
-			resolve,
-			reject
-		};
-		this.jobs.set(id, record);
-		this.pending.push(record);
-		if (options.signal) {
-			const cancel = () => this.cancel(id);
-			options.signal.addEventListener("abort", cancel, { once: true });
-			record.removeSignalListener = () => options.signal?.removeEventListener("abort", cancel);
-			if (options.signal.aborted) cancel();
-		}
-		this.runNext();
-		return this.handle(record);
-	}
-	get(id) {
-		const record = this.jobs.get(id);
-		return record ? this.handle(record) : void 0;
 	}
-	list() {
-		return [...this.jobs.values()].map(({ snapshot }) => ({ ...snapshot }));
+	async get(id) {
+		await this.ready;
+		return this.snapshots.get(id)?.chat ?? null;
+	}
+	async list() {
+		await this.ready;
+		return this.listSnapshot;
+	}
+	async send(id, content, options = {}, callbacks = {}) {
+		await this.ready;
+		if (options.signal?.aborted) throw canceledException();
+		const value = content.trim();
+		if (!value) throw new AIError("invalid_message", "Message must not be empty");
+		const controller = new AbortController();
+		const accepted = await this.mutate(async () => {
+			if (this.controllers.has(id)) throw new AIError("concurrent_request", "This chat already has an active generation");
+			const next = await this.repository.acceptSend(id, value);
+			this.controllers.set(id, controller);
+			this.setAccepted(next);
+			return next;
+		});
+		this.run(accepted, options, callbacks, controller);
+		return resultFromAccepted(accepted);
+	}
+	async cancel(id) {
+		await this.ready;
+		return this.mutate(async () => {
+			const controller = this.controllers.get(id);
+			const assistant = this.snapshots.get(id)?.messages.findLast((message) => message.role === "assistant");
+			if (!controller || !assistant || !isActiveMessage(assistant)) return false;
+			const next = await this.repository.markCanceling(id, assistant.id);
+			this.setAccepted(next);
+			controller.abort();
+			return true;
+		});
 	}
-	cancel(id) {
-		const record = this.jobs.get(id);
-		if (!record || !["queued", "running"].includes(record.snapshot.status)) return false;
-		record.controller.abort();
-		if (record.snapshot.status === "queued") {
-			const index = this.pending.indexOf(record);
-			if (index >= 0) this.pending.splice(index, 1);
-			const error = canceledError();
-			this.update(record, {
-				status: "canceled",
-				error
+	async retry(id, messageId, options = {}, callbacks = {}) {
+		await this.ready;
+		if (options.signal?.aborted) throw canceledException();
+		const controller = new AbortController();
+		const accepted = await this.mutate(async () => {
+			if (this.controllers.has(id)) throw new AIError("concurrent_request", "This chat already has an active generation");
+			const next = await this.repository.retry(id, messageId);
+			this.controllers.set(id, controller);
+			this.setAccepted(next);
+			return next;
+		});
+		this.run(accepted, options, callbacks, controller);
+		return resultFromAccepted(accepted);
+	}
+	async setTitle(id, title) {
+		await this.ready;
+		return this.mutate(async () => {
+			const chat$1 = await this.repository.setTitle(id, validTitle(title));
+			this.set({
+				chat: chat$1,
+				messages: this.snapshots.get(id)?.messages ?? []
 			});
-			record.removeSignalListener?.();
-			record.reject(error);
-		}
-		return true;
+			return chat$1;
+		});
 	}
-	handle(record) {
-		return {
-			id: record.snapshot.id,
-			promise: record.promise,
-			cancel: () => this.cancel(record.snapshot.id),
-			getSnapshot: () => ({ ...record.snapshot }),
-			subscribe: (listener) => {
-				record.listeners.add(listener);
-				listener({ ...record.snapshot });
-				return () => record.listeners.delete(listener);
+	async remove(id) {
+		await this.ready;
+		return this.mutate(async () => {
+			if (this.controllers.has(id)) throw new AIError("concurrent_request", "Cancel the generation before removing this chat");
+			const removed = await this.repository.remove(id);
+			if (removed) {
+				this.snapshots.delete(id);
+				this.refreshList();
+				this.emit(id);
 			}
+			return removed;
+		});
+	}
+	getChatSnapshot(id) {
+		return this.snapshots.get(id) ?? missingSnapshot;
+	}
+	getListSnapshot() {
+		return this.listSnapshot;
+	}
+	subscribeChat(id, listener) {
+		const listeners = this.chatListeners.get(id) ?? /* @__PURE__ */ new Set();
+		listeners.add(listener);
+		this.chatListeners.set(id, listeners);
+		return () => {
+			listeners.delete(listener);
+			if (listeners.size === 0) this.chatListeners.delete(id);
 		};
 	}
-	async runNext() {
-		if (this.running) return;
-		const record = this.pending.shift();
-		if (!record) return;
-		this.running = record;
-		this.update(record, {
-			status: "running",
-			startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	subscribeList(listener) {
+		this.listListeners.add(listener);
+		return () => this.listListeners.delete(listener);
+	}
+	async initialize() {
+		await this.repository.recoverActive();
+		const chats$1 = await this.repository.list();
+		const transcripts = await Promise.all(chats$1.map((chat$1) => this.repository.messages(chat$1.id)));
+		chats$1.forEach((chat$1, index) => {
+			this.snapshots.set(chat$1.id, {
+				chat: chat$1,
+				messages: transcripts[index] ?? []
+			});
 		});
+		this.refreshList();
+	}
+	run(accepted, options, callbacks, controller) {
+		const externalAbort = () => void this.cancel(accepted.chatId);
+		options.signal?.addEventListener("abort", externalAbort, { once: true });
+		if (options.signal?.aborted) externalAbort();
+		this.generate(accepted, options, callbacks, controller).finally(() => {
+			options.signal?.removeEventListener("abort", externalAbort);
+		}).catch(() => void 0);
+	}
+	async generate(accepted, options, callbacks, controller) {
+		let current = accepted.assistantMessage;
+		let content = "";
+		let lastPersistedAt = 0;
 		try {
-			const result = await this.executor({
-				...record.options,
-				signal: record.controller.signal,
-				onProgress: (progress) => {
-					record.options.onProgress?.(progress);
-					this.progress(record, progress);
-				}
+			const started = await this.mutate(async () => {
+				const next = await this.repository.start(accepted.chatId, accepted.assistantMessageId);
+				this.setAccepted(next);
+				return next;
 			});
-			this.update(record, {
-				status: "completed",
-				result,
-				completedAt: (/* @__PURE__ */ new Date()).toISOString()
+			current = started.assistantMessage;
+			const messages = historyBefore(started.messages, current, options.system);
+			const executorOptions = {
+				...options,
+				messages,
+				signal: controller.signal
+			};
+			delete executorOptions.system;
+			for await (const snapshot of this.executor.stream(executorOptions)) {
+				content = snapshot;
+				await this.mutate(async () => {
+					current = {
+						...current,
+						content,
+						updatedAt: now$1()
+					};
+					this.replaceMessage(started.chatId, current);
+					const timestamp$1 = Date.now();
+					if (timestamp$1 - lastPersistedAt >= 100) {
+						current = await this.repository.updateContent(current);
+						lastPersistedAt = timestamp$1;
+					}
+				});
+			}
+			await this.mutate(async () => {
+				const next = await this.repository.finish(started.chatId, current.id, controller.signal.aborted ? "canceled" : "completed", content, controller.signal.aborted ? canceledError$1() : void 0);
+				this.controllers.delete(started.chatId);
+				this.setAccepted(next);
+				if (next.assistantMessage.status === "completed") notify(callbacks.onFinish, next.assistantMessage);
+				else notify(callbacks.onError, next.assistantMessage.error);
 			});
-			record.resolve(result);
 		} catch (error) {
-			const canceled = record.controller.signal.aborted;
-			const failure = canceled ? canceledError(error) : error;
-			this.update(record, {
-				status: canceled ? "canceled" : "failed",
-				error: failure,
-				completedAt: (/* @__PURE__ */ new Date()).toISOString()
+			const serialized = controller.signal.aborted ? canceledError$1() : serializeError(error);
+			await this.mutate(async () => {
+				const next = await this.repository.finish(accepted.chatId, accepted.assistantMessageId, controller.signal.aborted ? "canceled" : "failed", content, serialized);
+				this.controllers.delete(accepted.chatId);
+				this.setAccepted(next);
+				notify(callbacks.onError, serialized);
 			});
-			record.reject(failure);
 		} finally {
-			record.removeSignalListener?.();
-			this.running = void 0;
-			this.runNext();
+			if (this.controllers.get(accepted.chatId) === controller) this.controllers.delete(accepted.chatId);
 		}
 	}
-	progress(record, progress) {
-		this.update(record, { progress });
+	mutate(action) {
+		const result = this.operation.then(action, action);
+		this.operation = result.then(() => void 0, () => void 0);
+		return result;
 	}
-	update(record, update) {
-		record.snapshot = {
-			...record.snapshot,
-			...update
-		};
-		for (const listener of record.listeners) listener({ ...record.snapshot });
+	setAccepted(value) {
+		this.set({
+			chat: value.chat,
+			messages: value.messages
+		});
+	}
+	replaceMessage(chatId, message) {
+		const snapshot = this.snapshots.get(chatId);
+		if (!snapshot) return;
+		this.set({
+			chat: snapshot.chat,
+			messages: snapshot.messages.map((item) => item.id === message.id ? message : item)
+		});
+	}
+	set(snapshot) {
+		if (!snapshot.chat) return;
+		const previous = this.snapshots.get(snapshot.chat.id);
+		this.snapshots.set(snapshot.chat.id, snapshot);
+		if (previous?.chat !== snapshot.chat) this.refreshList();
+		this.emit(snapshot.chat.id);
+	}
+	refreshList() {
+		this.listSnapshot = [...this.snapshots.values()].flatMap((snapshot) => snapshot.chat ? [snapshot.chat] : []).sort((left, right) => left.updatedAt === right.updatedAt ? right.id.localeCompare(left.id) : right.updatedAt.localeCompare(left.updatedAt));
+		for (const listener of this.listListeners) listener();
+	}
+	emit(id) {
+		for (const listener of this.chatListeners.get(id) ?? []) listener();
 	}
 };
-function canceledError(cause) {
-	return new AIError("generation_canceled", "Image generation canceled", cause);
+function historyBefore(messages, target, system) {
+	return [...system?.trim() ? [{
+		role: "system",
+		content: system
+	}] : [], ...messages.filter((message) => message.sequence < target.sequence && (message.role === "user" || message.status === "completed")).map((message) => ({
+		role: message.role,
+		content: message.content
+	}))];
+}
+function isActiveMessage(message) {
+	return message.role === "assistant" && (message.status === "queued" || message.status === "generating" || message.status === "canceling");
+}
+function resultFromAccepted(value) {
+	return {
+		chatId: value.chatId,
+		userMessageId: value.userMessageId,
+		assistantMessageId: value.assistantMessageId
+	};
+}
+function validTitle(title) {
+	const value = title.trim();
+	if (!value) throw new AIError("invalid_message", "Title must not be empty");
+	return value;
+}
+function serializeError(error) {
+	const value = error instanceof Error ? error : new Error(String(error));
+	const details = value;
+	return {
+		name: value.name,
+		message: value.message,
+		code: typeof details.code === "string" ? details.code : void 0,
+		stage: typeof details.stage === "string" ? details.stage : void 0
+	};
+}
+function canceledError$1() {
+	return {
+		name: "AIError",
+		code: "generation_canceled",
+		message: "Generation canceled"
+	};
+}
+function canceledException() {
+	return new AIError("generation_canceled", "Generation canceled");
+}
+function notify(callback, value) {
+	if (!callback) return;
+	Promise.resolve().then(() => callback(value)).catch(() => void 0);
+}
+function now$1() {
+	return (/* @__PURE__ */ new Date()).toISOString();
 }
 
 //#endregion
-//#region src/ai/image-models.ts
-const flux2Klein4B8BitAbliterated = {
-	formatVersion: 1,
-	model: "flux2-klein-4b-8bit-abliterated",
-	directory: "flux2-klein-4b-8bit-abliterated",
-	metadata: {
-		displayName: "Flux.2 Klein 4B Abliterated",
-		family: "flux2-klein",
-		precision: "8-bit",
-		estimatedMemoryGB: 12,
-		quality: "high",
-		speed: "fast",
-		capabilities: [
-			"text-to-image",
-			"image-to-image",
-			"inpainting",
-			"outpainting",
-			"references",
-			"lora"
-		]
-	},
-	components: {
-		textEncoder: {
-			repo: "mlx-community/Josiefied-Qwen3-4B-abliterated-v1-8bit",
-			revision: "main",
-			path: "text-encoder",
-			files: [
-				"config.json",
-				"tokenizer.json",
-				"tokenizer_config.json",
-				"*.safetensors",
-				"*.safetensors.index.json"
-			]
-		},
-		transformer: {
-			repo: "moxin-org/FLUX.2-klein-4B-8bit-mlx",
-			revision: "main",
-			path: "transformer",
-			files: ["config.json", "quantized_8bit.safetensors"]
-		},
-		vae: {
-			repo: "black-forest-labs/FLUX.2-klein-4B",
-			revision: "main",
-			path: "vae",
-			files: [
-				"config.json",
-				"diffusion_pytorch_model.safetensors",
-				"diffusion_pytorch_model.safetensors.index.json",
-				"diffusion_pytorch_model-*.safetensors"
-			]
+//#region src/ai/tokenizers.mjs
+var DictionarySplitter = class {
+	/**
+	* @param dictionary The dictionary of words to use for splitting.
+	*/
+	constructor(dictionary) {
+		this.trie = this._build_trie(dictionary);
+	}
+	/**
+	* Builds a trie from the given dictionary.
+	* @param dictionary The dictionary of words to build the trie from.
+	* @returns The root node of the trie.
+	* @private
+	*/
+	_build_trie(dictionary) {
+		const trie = /* @__PURE__ */ Object.create(null);
+		for (const word of dictionary) {
+			let node = trie;
+			for (let i = 0; i < word.length; ++i) {
+				const char = word[i];
+				node = node[char] ??= /* @__PURE__ */ Object.create(null);
+			}
+			node.end = word;
 		}
+		return trie;
 	}
-};
-const ternaryBonsaiImage4B = {
-	formatVersion: 1,
-	model: "ternary-bonsai-image-4b",
-	directory: "ternary-bonsai-image-4b",
-	metadata: {
-		displayName: "Ternary Bonsai Image 4B",
-		family: "bonsai-image",
-		precision: "2-bit",
-		estimatedMemoryGB: 8,
-		quality: "high",
-		speed: "fast",
-		capabilities: ["text-to-image"]
-	},
-	components: {
-		textEncoder: {
-			repo: "prism-ml/bonsai-image-ternary-4B-mlx-2bit",
-			revision: "2c24c81b934a658ba5590cf39088ba929985b4a8",
-			path: "text-encoder",
-			files: [
-				"text_encoder-mlx-4bit/config.json",
-				"text_encoder-mlx-4bit/tokenizer.json",
-				"text_encoder-mlx-4bit/tokenizer_config.json",
-				"text_encoder-mlx-4bit/model.safetensors",
-				"text_encoder-mlx-4bit/model.safetensors.index.json"
-			]
-		},
-		transformer: {
-			repo: "prism-ml/bonsai-image-ternary-4B-mlx-2bit",
-			revision: "2c24c81b934a658ba5590cf39088ba929985b4a8",
-			path: "transformer",
-			files: [
-				"transformer-packed-mflux/config.json",
-				"transformer-packed-mflux/diffusion_pytorch_model.safetensors",
-				"transformer-packed-mflux/quantization_config.json"
-			]
-		},
-		vae: {
-			repo: "prism-ml/bonsai-image-ternary-4B-mlx-2bit",
-			revision: "2c24c81b934a658ba5590cf39088ba929985b4a8",
-			path: "vae",
-			files: ["vae/config.json", "vae/diffusion_pytorch_model.safetensors"]
+	/**
+	* Splits the input text into tokens based on the dictionary.
+	* @param text The input text to split.
+	* @returns An array of tokens.
+	*/
+	split(text) {
+		const result = [];
+		const n = text.length;
+		let start = 0;
+		let i = 0;
+		while (i < n) {
+			let node = this.trie;
+			let match = null;
+			let j = i;
+			while (j < n && (node = node[text[j]])) {
+				if (node.end) match = node.end;
+				++j;
+			}
+			if (match) {
+				if (i > start) result.push(text.slice(start, i));
+				result.push(match);
+				i += match.length;
+				start = i;
+			} else ++i;
 		}
-	}
-};
-const imageModelManifests = [flux2Klein4B8BitAbliterated, ternaryBonsaiImage4B];
-function imageModelManifest(model) {
-	return imageModelManifests.find((manifest) => manifest.model === model);
-}
-const flux2KleinModelFiles = [
-	{
-		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
-		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
-		source: "config.json",
-		destination: "text-encoder/config.json",
-		bytes: 937
-	},
-	{
-		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
-		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
-		source: "tokenizer.json",
-		destination: "text-encoder/tokenizer.json",
-		bytes: 11422654
-	},
-	{
-		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
-		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
-		source: "tokenizer_config.json",
-		destination: "text-encoder/tokenizer_config.json",
-		bytes: 9706
-	},
-	{
-		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
-		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
-		source: "model.safetensors",
-		destination: "text-encoder/model.safetensors",
-		bytes: 4274158989
-	},
-	{
-		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
-		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
-		source: "model.safetensors.index.json",
-		destination: "text-encoder/model.safetensors.index.json",
-		bytes: 63924
-	},
-	{
-		repo: flux2Klein4B8BitAbliterated.components.transformer.repo,
-		revision: flux2Klein4B8BitAbliterated.components.transformer.revision,
-		source: "transformer/config.json",
-		destination: "transformer/config.json",
-		bytes: 541
-	},
-	{
-		repo: flux2Klein4B8BitAbliterated.components.transformer.repo,
-		revision: flux2Klein4B8BitAbliterated.components.transformer.revision,
-		source: "transformer/quantized_8bit.safetensors",
-		destination: "transformer/quantized_8bit.safetensors",
-		bytes: 4360050983
-	},
-	{
-		repo: flux2Klein4B8BitAbliterated.components.vae.repo,
-		revision: flux2Klein4B8BitAbliterated.components.vae.revision,
-		source: "vae/config.json",
-		destination: "vae/config.json",
-		bytes: 821
-	},
-	{
-		repo: flux2Klein4B8BitAbliterated.components.vae.repo,
-		revision: flux2Klein4B8BitAbliterated.components.vae.revision,
-		source: "vae/diffusion_pytorch_model.safetensors",
-		destination: "vae/diffusion_pytorch_model.safetensors",
-		bytes: 168120878
-	}
-];
-const flux2KleinTotalBytes = flux2KleinModelFiles.reduce((total, file) => total + file.bytes, 0);
-const bonsaiRepo = ternaryBonsaiImage4B.components.textEncoder.repo;
-const bonsaiRevision = ternaryBonsaiImage4B.components.textEncoder.revision;
-const ternaryBonsaiImageModelFiles = [
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "text_encoder-mlx-4bit/config.json",
-		destination: "text-encoder/config.json",
-		bytes: 937
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "text_encoder-mlx-4bit/tokenizer.json",
-		destination: "text-encoder/tokenizer.json",
-		bytes: 11422654
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "text_encoder-mlx-4bit/tokenizer_config.json",
-		destination: "text-encoder/tokenizer_config.json",
-		bytes: 9706
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "text_encoder-mlx-4bit/model.safetensors",
-		destination: "text-encoder/model.safetensors",
-		bytes: 2263022529
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "text_encoder-mlx-4bit/model.safetensors.index.json",
-		destination: "text-encoder/model.safetensors.index.json",
-		bytes: 63924
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "transformer-packed-mflux/config.json",
-		destination: "transformer/config.json",
-		bytes: 619
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "transformer-packed-mflux/diffusion_pytorch_model.safetensors",
-		destination: "transformer/diffusion_pytorch_model.safetensors",
-		bytes: 1425271472
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "transformer-packed-mflux/quantization_config.json",
-		destination: "transformer/quantization_config.json",
-		bytes: 5054
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "vae/config.json",
-		destination: "vae/config.json",
-		bytes: 821
-	},
-	{
-		repo: bonsaiRepo,
-		revision: bonsaiRevision,
-		source: "vae/diffusion_pytorch_model.safetensors",
-		destination: "vae/diffusion_pytorch_model.safetensors",
-		bytes: 168120878
-	}
-];
-const ternaryBonsaiImageTotalBytes = ternaryBonsaiImageModelFiles.reduce((total, file) => total + file.bytes, 0);
-function joinModelPath(root, component) {
-	return `${root.replace(/\/+$/, "")}/${component.replace(/^\/+/, "")}`;
-}
-function fluxImageModelPaths(path, manifest = flux2Klein4B8BitAbliterated) {
-	return {
-		path,
-		textEncoderPath: joinModelPath(path, manifest.components.textEncoder.path),
-		transformerPath: joinModelPath(path, manifest.components.transformer.path),
-		vaePath: joinModelPath(path, manifest.components.vae.path)
-	};
-}
-
-//#endregion
-//#region src/ai/image-schedule.ts
-function imageSigmaSchedule(schedules) {
-	const configured = schedules.filter((schedule) => schedule !== void 0);
-	if (configured.length === 0) return void 0;
-	const first = configured[0];
-	if (first.length === 0 || first.some((sigma, index) => !Number.isFinite(sigma) || sigma <= 0 || sigma > 1 || index > 0 && sigma >= first[index - 1])) throw new AIError("invalid_model", "LoRA sigmaSchedule must contain descending values greater than 0 and at most 1");
-	if (configured.some((schedule) => schedule.length !== first.length || schedule.some((sigma, index) => sigma !== first[index]))) throw new AIError("invalid_model", "Selected LoRAs require conflicting sigma schedules");
-	return [...first];
-}
-
-//#endregion
-//#region src/ai/image-upscale.ts
-function normalizeUpscaleScale(value) {
-	const scale = value ?? 2;
-	if (!Number.isFinite(scale) || scale <= 1 || scale > 4) throw new AIError("invalid_model", "Upscale scale must be greater than 1 and at most 4");
-	return scale;
-}
-
-//#endregion
-//#region src/ai/native.ts
-function bridge() {
-	try {
-		return (0, expo.requireNativeModule)("AI");
-	} catch (error) {
-		throw new AIError("unsupported_runtime", "bleam/ai requires the Bleam native runtime", error);
-	}
-}
-
-//#endregion
-//#region src/ai/tokenizers.mjs
-var DictionarySplitter = class {
-	/**
-	* @param dictionary The dictionary of words to use for splitting.
-	*/
-	constructor(dictionary) {
-		this.trie = this._build_trie(dictionary);
-	}
-	/**
-	* Builds a trie from the given dictionary.
-	* @param dictionary The dictionary of words to build the trie from.
-	* @returns The root node of the trie.
-	* @private
-	*/
-	_build_trie(dictionary) {
-		const trie = /* @__PURE__ */ Object.create(null);
-		for (const word of dictionary) {
-			let node = trie;
-			for (let i = 0; i < word.length; ++i) {
-				const char = word[i];
-				node = node[char] ??= /* @__PURE__ */ Object.create(null);
-			}
-			node.end = word;
-		}
-		return trie;
-	}
-	/**
-	* Splits the input text into tokens based on the dictionary.
-	* @param text The input text to split.
-	* @returns An array of tokens.
-	*/
-	split(text) {
-		const result = [];
-		const n = text.length;
-		let start = 0;
-		let i = 0;
-		while (i < n) {
-			let node = this.trie;
-			let match = null;
-			let j = i;
-			while (j < n && (node = node[text[j]])) {
-				if (node.end) match = node.end;
-				++j;
-			}
-			if (match) {
-				if (i > start) result.push(text.slice(start, i));
-				result.push(match);
-				i += match.length;
-				start = i;
-			} else ++i;
-		}
-		if (start < n) result.push(text.slice(start));
-		return result;
+		if (start < n) result.push(text.slice(start));
+		return result;
 	}
 };
 var DictionarySplitter_default = DictionarySplitter;
@@ -873,7 +730,7 @@ var create_pattern = (pattern, invert = true) => {
 		return null;
 	}
 };
-var escape_reg_exp = (string) => string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var escape_reg_exp = (string$1) => string$1.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var fuse_unk = (arr, tokens_to_ids, unk_token_id) => {
 	const fused = [];
 	let i = 0;
@@ -2595,16 +2452,16 @@ var ByteFallback = class extends Decoder_default {
 			if (bytes !== null) previous_byte_tokens.push(bytes);
 			else {
 				if (previous_byte_tokens.length > 0) {
-					const string = this.text_decoder.decode(Uint8Array.from(previous_byte_tokens));
-					new_tokens.push(string);
+					const string$1 = this.text_decoder.decode(Uint8Array.from(previous_byte_tokens));
+					new_tokens.push(string$1);
 					previous_byte_tokens = [];
 				}
 				new_tokens.push(token);
 			}
 		}
 		if (previous_byte_tokens.length > 0) {
-			const string = this.text_decoder.decode(Uint8Array.from(previous_byte_tokens));
-			new_tokens.push(string);
+			const string$1 = this.text_decoder.decode(Uint8Array.from(previous_byte_tokens));
+			new_tokens.push(string$1);
 			previous_byte_tokens = [];
 		}
 		return new_tokens;
@@ -2800,1857 +2657,2150 @@ var Tokenizer = class {
 var Tokenizer_default = Tokenizer;
 
 //#endregion
-//#region src/ai/image.ts
-function imageModelId(model) {
-	return typeof model === "string" ? model : model.id;
-}
-function imageModelDefinition(model) {
-	const id = imageModelId(model);
-	if (id === flux2Klein4B8BitAbliterated.model) return {
-		manifest: flux2Klein4B8BitAbliterated,
-		files: flux2KleinModelFiles,
-		totalBytes: flux2KleinTotalBytes
-	};
-	if (id === ternaryBonsaiImage4B.model) return {
-		manifest: ternaryBonsaiImage4B,
-		files: ternaryBonsaiImageModelFiles,
-		totalBytes: ternaryBonsaiImageTotalBytes
+//#region src/ai/bonsai-generation.ts
+async function prepareBonsaiGeneration(input) {
+	const state = await verifyBonsaiTextModel(input.model, { path: input.path });
+	if (!state.verified) throw new AIError("model_unavailable", `${input.model.id} is not prepared. Call prepareTextModel() before generation.`);
+	const tokenizer = new Tokenizer_default(await require_files.files.file(state.path, "tokenizer.json").json(), await require_files.files.file(state.path, "tokenizer_config.json").json());
+	const inputIds = tokenizer.encode(formatMessages(messagesFromInput(input))).ids.map(Number);
+	if (!inputIds.length || inputIds.some((token) => !Number.isInteger(token))) throw new AIError("invalid_message", "Tokenizer returned invalid token ids");
+	return {
+		request: {
+			id: input.id,
+			model: input.model.id,
+			modelPath: state.path,
+			inputIds,
+			endTokenIds: endTokenIds(input.model.id),
+			maxTokens: input.maxTokens,
+			temperature: input.temperature,
+			seed: input.seed
+		},
+		decode(tokenIds) {
+			return tokenIds.length ? tokenizer.decode(tokenIds, { skip_special_tokens: true }) : "";
+		}
 	};
-	throw new AIError("invalid_model", `Unsupported image model: ${id}`);
 }
-function modelCacheRoot(manifest) {
-	return require_files.files.directory(require_files.files.paths.models, manifest.directory);
+function messagesFromInput(input) {
+	if (input.messages) {
+		if (input.system !== void 0 || input.prompt !== void 0) throw new AIError("invalid_message", "messages cannot be combined with system or prompt");
+		if (!input.messages.length) throw new AIError("invalid_message", "Expected at least one message");
+		return input.messages;
+	}
+	if (!input.prompt?.trim()) throw new AIError("invalid_message", "Expected prompt");
+	return [...input.system ? [{
+		role: "system",
+		content: input.system
+	}] : [], {
+		role: "user",
+		content: input.prompt
+	}];
 }
-function assertImageModel(model) {
-	imageModelDefinition(model);
+function formatMessages(messages) {
+	if (messages[0]?.role === "assistant") throw new AIError("invalid_message", "Conversation cannot begin with assistant");
+	const parts = messages.map((message, index) => {
+		if (!message.content.trim()) throw new AIError("invalid_message", `Message ${index + 1} is empty`);
+		if (message.role === "system" && index !== 0) throw new AIError("invalid_message", "System message must be first");
+		return `<|im_start|>${message.role}\n${message.content}<|im_end|>\n`;
+	});
+	parts.push("<|im_start|>assistant\n<think>\n\n</think>\n\n");
+	return parts.join("");
 }
-function modelPathFromOptions(definition, path) {
-	return path ?? modelCacheRoot(definition.manifest).path;
+function endTokenIds(model) {
+	return model === "ternary-bonsai-27b" ? [248044, 248046] : [151643, 151645];
 }
-function downloadConcurrency(value) {
-	if (value === void 0) return 2;
-	if (!Number.isInteger(value)) throw new AIError("invalid_model", "concurrency must be an integer");
-	return Math.min(4, Math.max(1, value));
+
+//#endregion
+//#region src/ai/native.ts
+function bridge() {
+	try {
+		return (0, expo.requireNativeModule)("AI");
+	} catch (error) {
+		throw new AIError("unsupported_runtime", "bleam/ai requires the Bleam native runtime", error);
+	}
 }
-async function runConcurrent(items, concurrency, worker) {
-	let nextIndex = 0;
-	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-		while (nextIndex < items.length) {
-			const item = items[nextIndex];
-			nextIndex += 1;
-			await worker(item);
-		}
+
+//#endregion
+//#region src/ai/chat-executor.ts
+function generationId() {
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function foundationRequest(options, id) {
+	if (options.temperature !== void 0 && (!Number.isFinite(options.temperature) || options.temperature < 0)) throw new AIError("invalid_message", "temperature must be a non-negative number");
+	if (options.maxTokens !== void 0 && (!Number.isInteger(options.maxTokens) || options.maxTokens <= 0)) throw new AIError("invalid_message", "maxTokens must be a positive integer");
+	if (options.messages.length === 0) throw new AIError("invalid_message", "Expected at least one message");
+	let system;
+	const conversation = [];
+	for (const [index, message] of options.messages.entries()) {
+		if (!message.content.trim()) throw new AIError("invalid_message", `Message ${index + 1} is empty`);
+		if (message.role === "system") {
+			if (index !== 0 || system !== void 0) throw new AIError("invalid_message", "System message must be first");
+			system = message.content;
+		} else conversation.push({
+			role: message.role,
+			content: message.content
+		});
+	}
+	if (conversation[0]?.role === "assistant") throw new AIError("invalid_message", "Conversation cannot begin with assistant");
+	const final = conversation.at(-1);
+	if (final?.role !== "user") throw new AIError("invalid_message", "Conversation must end with a user message");
+	return {
+		id,
+		system,
+		prompt: final.content,
+		messages: conversation.slice(0, -1),
+		temperature: options.temperature,
+		maxTokens: options.maxTokens
+	};
+}
+async function* streamChat(options) {
+	if (options.model) {
+		yield* streamBonsaiChat(options);
+		return;
+	}
+	const id = generationId();
+	const native = bridge();
+	const updates = [];
+	let wake;
+	let settled = false;
+	let failure;
+	const updateSubscription = native.addListener?.("textGenerationUpdate", (event) => {
+		if (event.id !== id) return;
+		updates.push(event.content);
+		wake?.();
+		wake = void 0;
 	});
-	await Promise.all(workers);
+	const abort = () => void native.cancelTextGeneration?.(id);
+	options.signal.addEventListener("abort", abort, { once: true });
+	const completion = native.streamGenerate?.(foundationRequest(options, id)).catch((error) => {
+		failure = error;
+	}).finally(() => {
+		settled = true;
+		wake?.();
+		wake = void 0;
+	});
+	try {
+		if (options.signal.aborted) {
+			abort();
+			throw new AIError("generation_canceled", "Generation canceled");
+		}
+		if (!completion) throw new AIError("unsupported_runtime", "Streaming is unavailable in this runtime");
+		while (!settled || updates.length > 0) if (updates.length > 0) yield updates.shift();
+		else await new Promise((resolve) => {
+			wake = resolve;
+		});
+		await completion;
+		if (failure) throw mapNativeError(failure);
+	} finally {
+		if (!settled) await native.cancelTextGeneration?.(id);
+		options.signal.removeEventListener("abort", abort);
+		updateSubscription?.remove();
+	}
 }
-function hfResolveUrl(repo, revision, path) {
-	const encodedRepo = repo.split("/").map(encodeURIComponent).join("/");
-	const encodedPath = path.split("/").map(encodeURIComponent).join("/");
-	return `https://huggingface.co/${encodedRepo}/resolve/${encodeURIComponent(revision)}/${encodedPath}`;
+async function* streamBonsaiChat(options) {
+	const id = generationId();
+	const native = bridge();
+	if (options.signal.aborted) throw new AIError("generation_canceled", "Generation canceled");
+	const prepared = await prepareBonsaiGeneration({
+		id,
+		model: options.model,
+		path: options.path,
+		messages: options.messages,
+		temperature: options.temperature,
+		maxTokens: options.maxTokens,
+		seed: options.seed
+	});
+	if (options.signal.aborted) throw new AIError("generation_canceled", "Generation canceled");
+	const updates = [];
+	let wake;
+	let settled = false;
+	let failure;
+	const updateSubscription = native.addListener?.("localTextGenerationUpdate", (event) => {
+		if (event.id !== id) return;
+		updates.push(event.tokenIds);
+		wake?.();
+		wake = void 0;
+	});
+	const abort = () => void native.cancelTextGeneration?.(id);
+	options.signal.addEventListener("abort", abort, { once: true });
+	const completion = native.streamLocalText?.(prepared.request).catch((error) => {
+		failure = error;
+		return [];
+	}).finally(() => {
+		settled = true;
+		wake?.();
+		wake = void 0;
+	});
+	try {
+		if (!completion) throw new AIError("unsupported_runtime", "Local text streaming is unavailable in this runtime");
+		while (!settled || updates.length > 0) if (updates.length > 0) yield prepared.decode(updates.shift());
+		else await new Promise((resolve) => {
+			wake = resolve;
+		});
+		await completion;
+		if (failure) throw mapNativeError(failure);
+	} finally {
+		if (!settled) await native.cancelTextGeneration?.(id);
+		options.signal.removeEventListener("abort", abort);
+		updateSubscription?.remove();
+	}
 }
-const imageDimensionMultiple = 16;
-const minimumImageDimension = 64;
-const defaultImageLongSide = 1152;
-const aspectRatioValues = {
-	"1:1": [1, 1],
-	"16:9": [16, 9],
-	"9:16": [9, 16],
-	"4:3": [4, 3],
-	"3:2": [3, 2],
-	"2:3": [2, 3],
-	"21:9": [21, 9]
+
+//#endregion
+//#region src/ai/chat.tsx
+const chatShape = {
+	title: require_schema.string({ default: "New Chat" }),
+	status: require_schema.string({ default: "ready" })
 };
-function normalizedDimension(value) {
-	return Math.max(minimumImageDimension, Math.floor(value / imageDimensionMultiple) * imageDimensionMultiple);
+const errorShape = {
+	name: require_schema.string(),
+	message: require_schema.string(),
+	code: require_schema.string(),
+	stage: require_schema.string()
+};
+const messageShape = {
+	chatId: require_schema.string(),
+	role: require_schema.string(),
+	status: require_schema.string(),
+	content: require_schema.string({ default: "" }),
+	attempt: require_schema.number({ default: 1 }),
+	sequence: require_schema.number(),
+	error: require_schema.object(errorShape),
+	startedAt: require_schema.string(),
+	completedAt: require_schema.string()
+};
+const chats = require_state.atomCollection("__bleam_ai_chats", chatShape);
+const chatMessages = require_state.atomCollection("__bleam_ai_chat_messages", messageShape);
+var CollectionChatRepository = class {
+	async create(input) {
+		const insert = require_state.mutateAtom(chats, (mutation) => mutation.insert());
+		const id = await require_state.internalStore.set(require_state.internalJotaiWritableAtom(insert), {
+			title: input.title ?? "New Chat",
+			status: "ready"
+		});
+		return this.requireChat(id);
+	}
+	async get(id) {
+		const row = require_state.queryAtom(chats, (query) => query.row(id));
+		return chatFromRow(await require_state.internalStore.get(require_state.internalJotaiAtom(row)));
+	}
+	async list() {
+		const ids = require_state.queryAtom(chats, (query) => query.sortBy("updatedAt", "desc").ids());
+		const values = await require_state.internalStore.get(require_state.internalJotaiAtom(ids));
+		return Promise.all(values.map((id) => this.requireChat(id)));
+	}
+	async messages(chatId) {
+		const ids = require_state.queryAtom(chatMessages, (query) => query.where({ chatId }).sortBy("sequence").ids());
+		const values = await require_state.internalStore.get(require_state.internalJotaiAtom(ids));
+		return (await Promise.all(values.map((id) => this.messageRow(id)))).flatMap((row) => row ? [messageFromRow(row)] : []);
+	}
+	async acceptSend(chatId, content) {
+		const transaction = require_state.transactionAtom(async (tx) => {
+			const chat$1 = await tx.get(chats, chatId);
+			if (!chat$1) throw new Error(`Chat not found: ${chatId}`);
+			if (isActiveStatus(chat$1.data.status)) throw new Error("This chat already has an active generation");
+			const previousIds = await tx.query(chatMessages, (query) => query.where({ chatId }).sortBy("sequence", "desc").take(1).ids());
+			const sequence = ((previousIds[0] ? await tx.get(chatMessages, previousIds[0]) : null)?.data.sequence ?? 0) + 1;
+			const userId = await tx.insert(chatMessages, {
+				chatId,
+				role: "user",
+				status: "completed",
+				content,
+				attempt: 1,
+				sequence,
+				completedAt: timestamp()
+			});
+			const assistantId = await tx.insert(chatMessages, {
+				chatId,
+				role: "assistant",
+				status: "queued",
+				content: "",
+				attempt: 1,
+				sequence: sequence + 1
+			});
+			return acceptedFromTransaction(tx, await tx.update(chats, chatId, { status: "queued" }), assistantId, userId);
+		});
+		return require_state.internalStore.set(require_state.internalJotaiWritableAtom(transaction));
+	}
+	async start(chatId, messageId) {
+		return this.transition(chatId, messageId, async (tx, _chat, message) => {
+			if (message.data.status !== "queued") throw new Error("Only queued messages can start");
+			const startedAt = timestamp();
+			const assistant = await tx.update(chatMessages, messageId, {
+				status: "generating",
+				startedAt
+			});
+			return acceptedFromTransaction(tx, await tx.update(chats, chatId, { status: "generating" }), assistant.id);
+		});
+	}
+	async updateContent(message) {
+		const update = require_state.mutateAtom(chatMessages, (mutation) => mutation.update(message.id));
+		return messageFromRow(await require_state.internalStore.set(require_state.internalJotaiWritableAtom(update), { content: message.content }));
+	}
+	async markCanceling(chatId, messageId) {
+		return this.transition(chatId, messageId, async (tx, _chat, message) => {
+			if (!isActiveStatus(message.data.status ?? "")) throw new Error("Message is not active");
+			const assistant = await tx.update(chatMessages, messageId, { status: "canceling" });
+			return acceptedFromTransaction(tx, await tx.update(chats, chatId, { status: "canceling" }), assistant.id);
+		});
+	}
+	async finish(chatId, messageId, status, content, error) {
+		return this.transition(chatId, messageId, async (tx, _chat) => {
+			const completedAt = timestamp();
+			const assistant = await tx.update(chatMessages, messageId, {
+				status,
+				content,
+				error,
+				completedAt
+			});
+			return acceptedFromTransaction(tx, await tx.update(chats, chatId, { status: status === "completed" ? "ready" : status }), assistant.id);
+		});
+	}
+	async retry(chatId, messageId) {
+		return this.transition(chatId, messageId, async (tx, _chat, message) => {
+			const ids = await tx.query(chatMessages, (query) => query.where({ chatId }).sortBy("sequence", "desc").ids());
+			const rows = await Promise.all(ids.map((id) => tx.get(chatMessages, id)));
+			if (rows.find((row) => row?.data.role === "assistant")?.id !== messageId) throw new Error("Only the latest assistant message can be retried");
+			if (message.data.status !== "failed" && message.data.status !== "canceled") throw new Error("Only failed or canceled messages can be retried");
+			const assistant = await tx.update(chatMessages, messageId, {
+				status: "queued",
+				content: "",
+				attempt: message.data.attempt + 1,
+				error: void 0,
+				startedAt: void 0,
+				completedAt: void 0
+			});
+			const nextChat = await tx.update(chats, chatId, { status: "queued" });
+			const user = rows.find((row) => row?.data.role === "user" && (row.data.sequence ?? 0) < (assistant.data.sequence ?? 0));
+			return acceptedFromTransaction(tx, nextChat, assistant.id, user?.id);
+		});
+	}
+	async setTitle(id, title) {
+		const update = require_state.mutateAtom(chats, (mutation) => mutation.update(id));
+		return chatFromRow(await require_state.internalStore.set(require_state.internalJotaiWritableAtom(update), { title }));
+	}
+	async remove(id) {
+		const transaction = require_state.transactionAtom(async (tx) => {
+			const chat$1 = await tx.get(chats, id);
+			if (!chat$1) return false;
+			if (isActiveStatus(chat$1.data.status)) throw new Error("Active chats cannot be removed");
+			const ids = await tx.query(chatMessages, (query) => query.where({ chatId: id }).ids());
+			for (const messageId of ids) await tx.remove(chatMessages, messageId);
+			return tx.remove(chats, id);
+		});
+		return require_state.internalStore.set(require_state.internalJotaiWritableAtom(transaction));
+	}
+	async recoverActive() {
+		const transaction = require_state.transactionAtom(async (tx) => {
+			const chatIds = await tx.query(chats, (query) => query.ids());
+			for (const chatId of chatIds) {
+				const chat$1 = await tx.get(chats, chatId);
+				if (!chat$1) continue;
+				const messageIds = await tx.query(chatMessages, (query) => query.where({ chatId }).ids());
+				let recoveredMessage = false;
+				for (const messageId of messageIds) {
+					const message = await tx.get(chatMessages, messageId);
+					if (message?.data.role === "assistant" && isActiveStatus(message.data.status ?? "")) {
+						await tx.update(chatMessages, messageId, {
+							status: "canceled",
+							error: recoveryError(),
+							completedAt: timestamp()
+						});
+						recoveredMessage = true;
+					}
+				}
+				if (recoveredMessage || isActiveStatus(chat$1.data.status)) await tx.update(chats, chatId, { status: "canceled" });
+			}
+		});
+		await require_state.internalStore.set(require_state.internalJotaiWritableAtom(transaction));
+	}
+	async requireChat(id) {
+		const chat$1 = await this.get(id);
+		if (!chat$1) throw new Error(`Chat not found: ${id}`);
+		return chat$1;
+	}
+	async messageRow(id) {
+		const row = require_state.queryAtom(chatMessages, (query) => query.row(id));
+		return require_state.internalStore.get(require_state.internalJotaiAtom(row));
+	}
+	async transition(chatId, messageId, action) {
+		const transaction = require_state.transactionAtom(async (tx) => {
+			const chat$1 = await tx.get(chats, chatId);
+			const message = await tx.get(chatMessages, messageId);
+			if (!chat$1) throw new Error(`Chat not found: ${chatId}`);
+			if (!message || message.data.chatId !== chatId) throw new Error(`Message not found: ${messageId}`);
+			return action(tx, chat$1, message);
+		});
+		return require_state.internalStore.set(require_state.internalJotaiWritableAtom(transaction));
+	}
+};
+const managerKey = Symbol.for("bleam.ai.chatManager.v1");
+function managedChats() {
+	const scope = globalThis;
+	scope[managerKey] ??= new ChatManager(new CollectionChatRepository(), { stream(options) {
+		return streamChat(options);
+	} });
+	return scope[managerKey];
+}
+const chat = {
+	create(input = {}) {
+		return managedChats().create(input);
+	},
+	get(id) {
+		return managedChats().get(id);
+	},
+	list() {
+		return managedChats().list();
+	},
+	send(id, content, options) {
+		return managedChats().send(id, content, options);
+	},
+	cancel(id) {
+		return managedChats().cancel(id);
+	},
+	retry(id, messageId, options) {
+		return managedChats().retry(id, messageId, options);
+	},
+	setTitle(id, title) {
+		return managedChats().setTitle(id, title);
+	},
+	remove(id) {
+		return managedChats().remove(id);
+	}
+};
+function useChat(id, options = {}) {
+	const manager = managedChats();
+	(0, react.use)(manager.ready);
+	const snapshot = (0, react.useSyncExternalStore)((listener) => manager.subscribeChat(id, listener), () => manager.getChatSnapshot(id));
+	const generationOptions = optionsWithoutCallbacks(options);
+	const callbacks = {
+		onFinish: options.onFinish,
+		onError: options.onError
+	};
+	const status = snapshot.chat?.status ?? "not-found";
+	const active = status === "queued" || status === "generating" || status === "canceling";
+	const error = snapshot.messages.findLast((message) => message.role === "assistant")?.error;
+	return {
+		chat: snapshot.chat,
+		messages: snapshot.messages,
+		status,
+		error: error ?? null,
+		isGenerating: active,
+		canSend: snapshot.chat !== null && !active,
+		canCancel: status === "queued" || status === "generating",
+		send: (content, invocation) => manager.send(id, content, mergeOptions(generationOptions, invocation), callbacks),
+		cancel: () => manager.cancel(id),
+		retry: (messageId, invocation) => manager.retry(id, messageId, mergeOptions(generationOptions, invocation), callbacks),
+		setTitle: (title) => manager.setTitle(id, title),
+		remove: () => manager.remove(id)
+	};
 }
-function normalizeImageSize(size, maxLongSide = defaultImageLongSide) {
-	if (!Number.isFinite(size.width) || size.width <= 0) throw new AIError("invalid_model", "size.width must be positive");
-	if (!Number.isFinite(size.height) || size.height <= 0) throw new AIError("invalid_model", "size.height must be positive");
-	if (maxLongSide !== false && (!Number.isInteger(maxLongSide) || maxLongSide < minimumImageDimension)) throw new AIError("invalid_model", `maxLongSide must be false or an integer of at least ${minimumImageDimension}`);
-	const scale = maxLongSide === false ? 1 : Math.min(1, maxLongSide / Math.max(size.width, size.height));
+function useChatList() {
+	const manager = managedChats();
+	(0, react.use)(manager.ready);
+	return (0, react.useSyncExternalStore)((listener) => manager.subscribeList(listener), () => manager.getListSnapshot());
+}
+async function acceptedFromTransaction(tx, chatRow, assistantId, userId) {
+	const ids = await tx.query(chatMessages, (query) => query.where({ chatId: chatRow.id }).sortBy("sequence").ids());
+	const messages = (await Promise.all(ids.map((id) => tx.get(chatMessages, id)))).flatMap((row) => row ? [messageFromRow(row)] : []);
+	const assistantMessage = messages.find((message) => message.id === assistantId);
+	if (assistantMessage?.role !== "assistant") throw new Error(`Assistant message not found: ${assistantId}`);
+	const userMessage = userId ? messages.find((message) => message.id === userId) : void 0;
 	return {
-		width: normalizedDimension(size.width * scale),
-		height: normalizedDimension(size.height * scale)
+		chatId: chatRow.id,
+		userMessageId: userMessage?.id ?? "",
+		assistantMessageId: assistantId,
+		chat: chatFromRow(chatRow),
+		userMessage,
+		assistantMessage,
+		messages
 	};
 }
-function imageSizeForPreset(aspectRatio, maxLongSide = defaultImageLongSide) {
-	const ratio = aspectRatioValues[aspectRatio];
-	if (!ratio) throw new AIError("invalid_model", `Unsupported image aspect ratio: ${aspectRatio}`);
-	assertPositiveInteger(maxLongSide, "maxLongSide");
-	const [widthRatio, heightRatio] = ratio;
-	return normalizeImageSize(widthRatio >= heightRatio ? {
-		width: maxLongSide,
-		height: maxLongSide * heightRatio / widthRatio
-	} : {
-		width: maxLongSide * widthRatio / heightRatio,
-		height: maxLongSide
-	}, maxLongSide);
+function chatFromRow(row) {
+	if (!row) return null;
+	return {
+		id: row.id,
+		title: row.data.title,
+		status: row.data.status,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt
+	};
 }
-function imageLoRARoot() {
-	return require_files.files.directory(require_files.files.paths.models, "image-loras");
+function messageFromRow(row) {
+	return {
+		id: row.id,
+		chatId: row.data.chatId,
+		role: row.data.role,
+		status: row.data.status,
+		content: row.data.content,
+		attempt: row.data.attempt,
+		sequence: row.data.sequence,
+		error: row.data.error,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		startedAt: row.data.startedAt,
+		completedAt: row.data.completedAt
+	};
 }
-function safeCacheName(value, name) {
-	const trimmed = value.trim();
-	if (!trimmed) throw new AIError("invalid_model", `${name} must not be empty`);
-	return trimmed.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+function optionsWithoutCallbacks(options) {
+	const { onFinish: _onFinish, onError: _onError,...generation } = options;
+	return generation;
 }
-function sourceFileName(lora) {
-	if (lora.source.type === "local") return lora.source.path.split("/").pop() || `${lora.id}.safetensors`;
-	if (lora.source.type === "url") return lora.source.filename ?? lora.source.url.split("/").pop() ?? `${lora.id}.safetensors`;
-	return lora.source.path?.split("/").pop() || `${lora.id}.safetensors`;
+function mergeOptions(defaults, invocation) {
+	return {
+		...defaults,
+		...invocation
+	};
 }
-function assertLoRAScale(scale, name = "lora.scale") {
-	const value = scale ?? 1;
-	if (!Number.isFinite(value) || value <= 0) throw new AIError("invalid_model", `${name} must be a positive number`);
-	return value;
+function isActiveStatus(status) {
+	return status === "queued" || status === "generating" || status === "canceling";
 }
-function assertLoRADefinition(lora) {
-	safeCacheName(lora.id, "lora.id");
-	assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
-	imageSigmaSchedule([lora.metadata?.sigmaSchedule]);
-	if (lora.metadata?.baseModel !== void 0) assertImageModel(lora.metadata.baseModel);
-	if (lora.metadata?.precision !== void 0 && ![
-		"float16",
-		"bfloat16",
-		"float32"
-	].includes(lora.metadata.precision)) throw new AIError("invalid_model", "lora.metadata.precision is unsupported");
+function recoveryError() {
+	return {
+		name: "AIError",
+		code: "generation_canceled",
+		message: "Generation was interrupted when the app exited"
+	};
 }
-function assertLoRACompatibility(lora, model) {
-	if (lora.metadata?.baseModel && lora.metadata.baseModel !== model) throw new AIError("invalid_model", `LoRA ${lora.id} targets ${lora.metadata.baseModel}, not ${model}`);
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
 }
-const commonLoRAFileNames = [
-	"pytorch_lora_weights.safetensors",
-	"adapter_model.safetensors",
-	"lora.safetensors",
-	"model.safetensors"
-];
-async function resolveHuggingFaceLoRA(lora, options) {
-	if (lora.source.type !== "huggingface" || lora.source.path) return lora;
-	const revision = lora.source.revision ?? "main";
-	const manifestFile = imageLoRARoot().directory(safeCacheName(lora.id, "lora.id")).file("manifest.json");
-	if ((await manifestFile.stat()).type === "file") {
-		const manifest = await manifestFile.json();
-		if (isRecord(manifest) && isRecord(manifest.source) && manifest.source.type === "huggingface" && manifest.source.repo === lora.source.repo && (manifest.source.revision ?? "main") === revision && typeof manifest.source.path === "string") return {
-			...lora,
-			source: {
-				...lora.source,
-				revision,
-				path: manifest.source.path,
-				bytes: lora.source.bytes ?? (typeof manifest.source.bytes === "number" ? manifest.source.bytes : void 0)
-			}
-		};
-	}
-	const encodedRepo = lora.source.repo.split("/").map(encodeURIComponent).join("/");
-	const response = await fetch(`https://huggingface.co/api/models/${encodedRepo}/revision/${encodeURIComponent(revision)}`, {
-		headers: options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0,
-		signal: options.signal
-	});
-	if (!response.ok) throw new AIError("invalid_model", `Unable to inspect Hugging Face LoRA ${lora.source.repo}: ${response.status}`);
-	const value = await response.json();
-	const siblings = isRecord(value) && Array.isArray(value.siblings) ? value.siblings.flatMap((item) => {
-		if (!isRecord(item) || typeof item.rfilename !== "string") return [];
-		return [{
-			path: item.rfilename,
-			bytes: typeof item.size === "number" ? item.size : void 0
-		}];
-	}) : [];
-	const common = commonLoRAFileNames.map((name) => siblings.find((file) => file.path === name)).find(Boolean);
-	const safetensors = siblings.filter((file) => file.path.endsWith(".safetensors"));
-	const selected = common ?? (safetensors.length === 1 ? safetensors[0] : void 0);
-	if (!selected) {
-		const candidates = safetensors.map((file) => file.path).join(", ");
-		throw new AIError("invalid_model", candidates ? `Multiple LoRA weights found for ${lora.id}; set source.path to one of: ${candidates}` : `No .safetensors LoRA weight found for ${lora.id}`);
+
+//#endregion
+//#region src/ai/image-batch.ts
+function batchImageSeeds(count, seed) {
+	if (!Number.isInteger(count) || count < 1 || count > 64) throw new AIError("invalid_message", "Batch count must be an integer from 1 to 64");
+	const first = seed ?? Math.floor(Math.random() * 4294967296);
+	return Array.from({ length: count }, (_, index) => first + index >>> 0);
+}
+
+//#endregion
+//#region src/ai/image-jobs.ts
+const jobShape = {
+	status: require_schema.string({ default: "paused" }),
+	request: require_schema.string({ default: "{}" }),
+	progress: require_schema.string({ default: "" }),
+	result: require_schema.string({ default: "" }),
+	error: require_schema.string({ default: "" }),
+	attempt: require_schema.number({ default: 1 }),
+	startedAt: require_schema.string({ default: "" }),
+	completedAt: require_schema.string({ default: "" })
+};
+var CollectionImageJobRepository = class {
+	records = require_state.atomCollection("__bleam_ai_jobs", jobShape);
+	insertRecord = require_state.mutateAtom(this.records, (mutation) => mutation.insert());
+	async list() {
+		const ids = await require_state.internalStore.get(require_state.internalJotaiAtom(this.records));
+		return (await Promise.all(ids.map((id) => this.getRow(id)))).flatMap((row) => row ? [jobFromRow(row)] : []);
+	}
+	async insert(job) {
+		const id = await require_state.internalStore.set(require_state.internalJotaiWritableAtom(this.insertRecord), dataFromJob(job));
+		const row = await this.getRow(id);
+		if (!row) throw new Error(`Could not load inserted image job ${id}`);
+		return jobFromRow(row);
+	}
+	async update(job) {
+		const updateRecord = require_state.mutateAtom(this.records, (mutation) => mutation.update(job.id));
+		return jobFromRow(await require_state.internalStore.set(require_state.internalJotaiWritableAtom(updateRecord), dataFromJob(job)));
+	}
+	async remove(id) {
+		const removeRecord = require_state.mutateAtom(this.records, (mutation) => mutation.remove(id));
+		await require_state.internalStore.set(require_state.internalJotaiWritableAtom(removeRecord));
+	}
+	async getRow(id) {
+		const row = require_state.queryAtom(this.records, (query) => query.row(id));
+		return require_state.internalStore.get(require_state.internalJotaiAtom(row));
 	}
-	return {
-		...lora,
-		source: {
-			...lora.source,
-			revision,
-			path: selected.path,
-			bytes: lora.source.bytes ?? selected.bytes
+};
+var ImageJobManager = class {
+	records = /* @__PURE__ */ new Map();
+	jobListeners = /* @__PURE__ */ new Map();
+	listListeners = /* @__PURE__ */ new Set();
+	listSnapshot = [];
+	operation = Promise.resolve();
+	pumping = false;
+	runningId;
+	controller;
+	ready;
+	constructor(repository, executor, jobFiles = nativeImageJobFiles) {
+		this.repository = repository;
+		this.executor = executor;
+		this.jobFiles = jobFiles;
+		this.ready = this.initialize();
+	}
+	setExecutor(executor) {
+		this.executor = executor;
+	}
+	async queue(options) {
+		await this.ready;
+		const request = normalizeRequest(options);
+		const provisional = await this.repository.insert({
+			kind: "image",
+			status: "paused",
+			request,
+			attempt: 0
+		});
+		try {
+			const preparedRequest = await this.jobFiles.prepare(provisional.id, request);
+			const queued = await this.repository.update({
+				...provisional,
+				status: "queued",
+				request: preparedRequest,
+				attempt: 1
+			});
+			this.set(queued);
+			this.pump();
+			return queued;
+		} catch (error) {
+			await this.repository.remove(provisional.id);
+			await this.jobFiles.remove(provisional).catch(() => void 0);
+			throw error;
 		}
-	};
-}
-function loraUrl(lora) {
-	if (lora.source.type === "url") return lora.source.url;
-	if (lora.source.type === "huggingface") {
-		if (!lora.source.path) return void 0;
-		return hfResolveUrl(lora.source.repo, lora.source.revision ?? "main", lora.source.path);
 	}
-}
-function loraExpectedBytes(lora) {
-	return lora.source.type === "local" ? void 0 : lora.source.bytes;
-}
-function hasSafetensorsHeader(size) {
-	return size !== void 0 && size > 8;
-}
-function loraHeaders(lora, accessToken) {
-	return lora.source.type === "huggingface" && accessToken ? { Authorization: `Bearer ${accessToken}` } : void 0;
-}
-function cachedLoRAFile(lora) {
-	const id = safeCacheName(lora.id, "lora.id");
-	return imageLoRARoot().directory(id).file(safeCacheName(sourceFileName(lora), "lora filename"));
-}
-async function ensureModelFile(input) {
-	const destination = require_files.files.file(input.path, input.file.destination);
-	const stat = await destination.stat();
-	if (stat.type === "file" && stat.size === input.file.bytes) {
-		input.onProgress?.({
-			model: input.model,
-			file: input.file.destination,
-			index: input.index,
-			total: input.total,
-			bytesWritten: input.file.bytes,
-			totalBytes: input.file.bytes,
-			fraction: 1
+	async get(id) {
+		await this.ready;
+		return this.records.get(id);
+	}
+	async list() {
+		await this.ready;
+		return this.listSnapshot;
+	}
+	async cancel(id) {
+		await this.ready;
+		return this.mutate(async () => {
+			const job = this.records.get(id);
+			if (!job) return false;
+			if (job.status === "queued" || job.status === "paused") {
+				await this.replace(job, {
+					status: "canceled",
+					error: canceledError(),
+					completedAt: now()
+				});
+				return true;
+			}
+			if (job.status !== "running") return false;
+			await this.replace(job, { status: "canceling" });
+			if (this.runningId === id) this.controller?.abort();
+			return true;
 		});
-		return;
 	}
-	await destination.download(hfResolveUrl(input.file.repo, input.file.revision, input.file.source), {
-		headers: input.headers,
-		expectedBytes: input.file.bytes,
-		atomic: true,
-		resume: true,
-		onProgress(progress) {
-			input.onProgress?.({
-				model: input.model,
-				file: input.file.destination,
-				index: input.index,
-				total: input.total,
-				...progress
+	async retry(id) {
+		await this.ready;
+		const resumed = await this.mutate(async () => {
+			const job = this.records.get(id);
+			if (!job || job.status !== "failed" && job.status !== "canceled") return false;
+			await this.replace(job, {
+				status: "queued",
+				attempt: job.attempt + 1,
+				progress: void 0,
+				result: void 0,
+				error: void 0,
+				startedAt: void 0,
+				completedAt: void 0
+			});
+			return true;
+		});
+		if (resumed) this.pump();
+		return resumed;
+	}
+	async resume(id) {
+		await this.ready;
+		const resumed = await this.mutate(async () => {
+			const job = this.records.get(id);
+			if (job?.status !== "paused") return false;
+			await this.replace(job, { status: "queued" });
+			return true;
+		});
+		if (resumed) this.pump();
+		return resumed;
+	}
+	async remove(id) {
+		await this.ready;
+		return this.mutate(async () => {
+			const job = this.records.get(id);
+			if (!job) return false;
+			if (job.status === "queued" || job.status === "running" || job.status === "canceling") throw new AIError("concurrent_request", "Cancel the image job before removing it");
+			await this.jobFiles.remove(job);
+			await this.repository.remove(id);
+			this.records.delete(id);
+			this.refreshList();
+			this.emit(id);
+			return true;
+		});
+	}
+	getJobSnapshot(id) {
+		return this.records.get(id);
+	}
+	getListSnapshot() {
+		return this.listSnapshot;
+	}
+	subscribeJob(id, listener) {
+		const listeners = this.jobListeners.get(id) ?? /* @__PURE__ */ new Set();
+		listeners.add(listener);
+		this.jobListeners.set(id, listeners);
+		return () => {
+			listeners.delete(listener);
+			if (listeners.size === 0) this.jobListeners.delete(id);
+		};
+	}
+	subscribeList(listener) {
+		this.listListeners.add(listener);
+		return () => this.listListeners.delete(listener);
+	}
+	async initialize() {
+		const jobs$1 = await this.repository.list();
+		for (const job of jobs$1) {
+			if (job.status === "paused" && job.attempt === 0) {
+				await this.repository.remove(job.id);
+				await this.jobFiles.remove(job).catch(() => void 0);
+				continue;
+			}
+			let recovered = job;
+			if (job.status === "running" || job.status === "canceling") recovered = await this.repository.update({
+				...job,
+				status: "canceled",
+				error: canceledError("Generation was interrupted when the app exited"),
+				completedAt: now()
 			});
+			else if (job.status === "queued") recovered = await this.repository.update({
+				...job,
+				status: "paused"
+			});
+			this.records.set(recovered.id, recovered);
 		}
-	}).result;
-}
-async function writePreparedManifest(path, manifest) {
-	await require_files.files.file(path, "manifest.json").write(JSON.stringify(manifest, null, 2));
-}
-async function imageModelState(model, path) {
-	const definition = imageModelDefinition(model);
-	let bytesPresent = 0;
-	const missingFiles = [];
-	const invalidFiles = [];
-	for (const file of definition.files) {
-		const stat = await require_files.files.file(path, file.destination).stat();
-		if (stat.type !== "file") {
-			missingFiles.push(file.destination);
-			continue;
+		this.refreshList();
+	}
+	mutate(action) {
+		const result = this.operation.then(action, action);
+		this.operation = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	pump() {
+		if (this.pumping) return;
+		this.pumping = true;
+		this.runLoop().finally(() => {
+			this.pumping = false;
+			if (this.nextQueued()) this.pump();
+		});
+	}
+	async runLoop() {
+		while (true) {
+			const job = await this.mutate(async () => {
+				const next = this.nextQueued();
+				if (!next) return void 0;
+				this.runningId = next.id;
+				this.controller = new AbortController();
+				return this.replace(next, {
+					status: "running",
+					startedAt: now(),
+					completedAt: void 0,
+					error: void 0,
+					progress: void 0
+				});
+			});
+			if (!job) return;
+			const controller = this.controller;
+			try {
+				const result = await this.executor({
+					...job.request,
+					signal: controller.signal,
+					onProgress: (progress) => {
+						this.mutate(async () => {
+							const current = this.records.get(job.id);
+							if (current?.status === "running") await this.replace(current, { progress });
+						});
+					}
+				});
+				await this.mutate(async () => {
+					const current = this.records.get(job.id);
+					if (!current) return;
+					if (controller.signal.aborted || current.status === "canceling") {
+						await this.replace(current, {
+							status: "canceled",
+							error: canceledError(),
+							completedAt: now()
+						});
+						return;
+					}
+					await this.replace(current, {
+						status: "completed",
+						progress: {
+							currentStep: 1,
+							totalSteps: 1,
+							fraction: 1
+						},
+						result,
+						completedAt: now()
+					});
+				});
+			} catch (error) {
+				await this.mutate(async () => {
+					const current = this.records.get(job.id);
+					if (!current) return;
+					const canceled = controller.signal.aborted || current.status === "canceling";
+					await this.replace(current, {
+						status: canceled ? "canceled" : "failed",
+						error: canceled ? canceledError() : serializedError(error),
+						completedAt: now()
+					});
+				});
+			} finally {
+				this.runningId = void 0;
+				this.controller = void 0;
+			}
 		}
-		bytesPresent += Math.min(stat.size ?? 0, file.bytes);
-		if (stat.size !== file.bytes) invalidFiles.push(file.destination);
 	}
-	const manifestStat = await require_files.files.file(path, "manifest.json").stat();
-	if (manifestStat.type !== "file") missingFiles.push("manifest.json");
-	const installed = missingFiles.length === 0;
+	nextQueued() {
+		return [...this.records.values()].filter((job) => job.status === "queued").sort((left, right) => left.createdAt === right.createdAt ? left.id.localeCompare(right.id) : left.createdAt.localeCompare(right.createdAt))[0];
+	}
+	async replace(job, update) {
+		const persisted = await this.repository.update({
+			...job,
+			...update
+		});
+		this.set(persisted);
+		return persisted;
+	}
+	set(job) {
+		this.records.set(job.id, job);
+		this.refreshList();
+		this.emit(job.id);
+	}
+	refreshList() {
+		this.listSnapshot = [...this.records.values()].sort((left, right) => left.createdAt === right.createdAt ? right.id.localeCompare(left.id) : right.createdAt.localeCompare(left.createdAt)).map(summaryFromJob);
+		for (const listener of this.listListeners) listener();
+	}
+	emit(id) {
+		for (const listener of this.jobListeners.get(id) ?? []) listener();
+	}
+};
+function useManagedJob(manager, id) {
+	(0, react.use)(manager.ready);
+	return (0, react.useSyncExternalStore)((listener) => manager.subscribeJob(id, listener), () => manager.getJobSnapshot(id));
+}
+function useManagedJobList(manager) {
+	(0, react.use)(manager.ready);
+	return (0, react.useSyncExternalStore)((listener) => manager.subscribeList(listener), () => manager.getListSnapshot());
+}
+const nativeImageJobFiles = {
+	async prepare(id, request) {
+		const inputs = jobRoot(id).directory("Inputs");
+		await inputs.create();
+		return {
+			...request,
+			image: request.image ? await copyInput(request.image, inputs.path, "Image") : void 0,
+			mask: request.mask ? await copyInput(request.mask, inputs.path, "Mask") : void 0,
+			references: request.references ? await Promise.all(request.references.map((reference, index) => copyInput(reference, inputs.path, `Reference-${index + 1}`))) : void 0,
+			loras: request.loras ? await Promise.all(request.loras.map(async (lora, index) => lora.source.type === "local" ? {
+				...lora,
+				source: {
+					...lora.source,
+					path: await copyInput(lora.source.path, inputs.path, `LoRA-${index + 1}`, ".safetensors")
+				}
+			} : lora)) : void 0
+		};
+	},
+	async remove(job) {
+		await jobRoot(job.id).delete().catch(() => void 0);
+		if (job.result?.uri) await require_files.files.file(pathFromUri(job.result.uri)).delete().catch(() => void 0);
+	}
+};
+function dataFromJob(job) {
 	return {
-		model,
-		path,
-		paths: fluxImageModelPaths(path, definition.manifest),
-		installed,
-		verified: installed && invalidFiles.length === 0 && manifestStat.type === "file",
-		bytesPresent,
-		totalBytes: definition.totalBytes,
-		missingFiles,
-		invalidFiles
+		status: job.status,
+		request: JSON.stringify(job.request),
+		progress: encode(job.progress),
+		result: encode(job.result),
+		error: encode(job.error),
+		attempt: job.attempt,
+		startedAt: job.startedAt ?? "",
+		completedAt: job.completedAt ?? ""
 	};
 }
-function tokenArray(value, name) {
-	const candidate = isRecord(value) && "data" in value ? value.data : value;
-	const values = Array.isArray(candidate) ? candidate : ArrayBuffer.isView(candidate) ? Array.from(candidate) : void 0;
-	if (!values) throw new AIError("invalid_message", `Tokenizer did not return ${name}`);
-	return values.map((token) => {
-		const number = typeof token === "bigint" ? Number(token) : token;
-		if (!Number.isInteger(number) || number < 0) throw new AIError("invalid_message", `${name} must contain token ids`);
-		return number;
+function jobFromRow(row) {
+	return {
+		id: row.id,
+		kind: "image",
+		status: row.data.status,
+		request: decode(row.data.request),
+		progress: decode(row.data.progress),
+		result: decode(row.data.result),
+		error: decode(row.data.error),
+		attempt: row.data.attempt,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		startedAt: row.data.startedAt || void 0,
+		completedAt: row.data.completedAt || void 0
+	};
+}
+function encode(value) {
+	return value === void 0 ? "" : JSON.stringify(value);
+}
+function decode(value) {
+	return value ? JSON.parse(value) : void 0;
+}
+function normalizeRequest(options) {
+	const runtimeOptions = options;
+	for (const key of [
+		"accessToken",
+		"onModelProgress",
+		"onProgress",
+		"signal",
+		"tokenizer"
+	]) if (runtimeOptions[key] !== void 0) throw new AIError("invalid_message", `${key} is not supported for persistent image jobs`);
+	if (!options.prompt.trim()) throw new AIError("invalid_message", "Expected prompt");
+	assertSerializable(options);
+	return {
+		...options,
+		model: typeof options.model === "string" ? options.model : options.model?.id,
+		seed: options.seed ?? Math.floor(Math.random() * 4294967296)
+	};
+}
+function assertSerializable(value, path = "options") {
+	if (typeof value === "number" && !Number.isFinite(value)) throw new AIError("invalid_message", `${path} must be finite`);
+	if (typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") throw new AIError("invalid_message", `${path} must be serializable`);
+	if (Array.isArray(value)) value.forEach((next, index) => {
+		assertSerializable(next, `${path}[${index}]`);
 	});
+	else if (value && typeof value === "object") for (const [key, next] of Object.entries(value)) assertSerializable(next, `${path}.${key}`);
 }
-async function createFluxTokenizer(path, manifest) {
-	const paths = fluxImageModelPaths(path, manifest);
-	const tokenizer = new Tokenizer_default(await require_files.files.file(paths.textEncoderPath, "tokenizer.json").json(), await require_files.files.file(paths.textEncoderPath, "tokenizer_config.json").json());
-	const padTokenId = 151643;
-	return ({ prompt, maxLength }) => {
-		const inputIds = tokenArray(tokenizer.encode(formatQwen3KleinPrompt(prompt)).ids, "inputIds").slice(0, maxLength);
-		const attentionMask = inputIds.map(() => 1);
-		while (inputIds.length < maxLength) {
-			inputIds.push(padTokenId);
-			attentionMask.push(0);
-		}
-		return {
-			inputIds,
-			attentionMask
-		};
+function serializedError(error) {
+	const value = error instanceof Error ? error : new Error(String(error));
+	const record = value;
+	return {
+		name: value.name,
+		message: value.message,
+		code: typeof record.code === "string" ? record.code : void 0,
+		stage: typeof record.stage === "string" ? record.stage : void 0
 	};
 }
-function formatQwen3KleinPrompt(prompt) {
-	return [
-		"<|im_start|>user",
-		`${prompt.replaceAll("[IMG]", "")}<|im_end|>`,
-		"<|im_start|>assistant",
-		"<think>",
-		"",
-		"</think>",
-		""
-	].join("\n");
+function canceledError(message = "Image generation canceled") {
+	return {
+		name: "AIError",
+		code: "generation_canceled",
+		message
+	};
 }
-function assertPositiveInteger(value, name) {
-	if (!Number.isInteger(value) || value <= 0) throw new AIError("invalid_model", `${name} must be a positive integer`);
+function summaryFromJob(job) {
+	return {
+		id: job.id,
+		kind: job.kind,
+		status: job.status,
+		prompt: job.request.prompt,
+		progress: job.progress,
+		attempt: job.attempt,
+		createdAt: job.createdAt,
+		updatedAt: job.updatedAt,
+		startedAt: job.startedAt,
+		completedAt: job.completedAt
+	};
 }
-function assertUnitInterval(value, name) {
-	if (!Number.isFinite(value) || value <= 0 || value > 1) throw new AIError("invalid_model", `${name} must be greater than 0 and at most 1`);
+function jobRoot(id) {
+	return require_files.files.directory(require_files.files.paths.shared, "ImageJobs", require_app_storage.currentAppStorageKey(), id);
 }
-function filePathFromUri(value, name) {
-	const path = value.trim();
-	if (!path) throw new AIError("invalid_message", `${name} must not be empty`);
-	if (!path.startsWith("file://")) return path;
+async function copyInput(source, directory, name, fallbackExtension = ".png") {
+	const path = pathFromUri(source);
+	const destination = `${directory}/${name}${path.match(/\.[A-Za-z0-9]+$/)?.[0] ?? fallbackExtension}`;
+	await require_files.nativeCopy(path, destination);
+	return destination;
+}
+function pathFromUri(value) {
+	if (!value.startsWith("file://")) return value;
 	try {
-		return decodeURIComponent(new URL(path).pathname);
-	} catch (error) {
-		throw new AIError("invalid_message", `Invalid ${name} file URI`, error);
+		return decodeURIComponent(new URL(value).pathname);
+	} catch {
+		return value.slice(7);
 	}
 }
-function assertTokenArray(value, name) {
-	if (value.length === 0) throw new AIError("invalid_message", `${name} must not be empty`);
-	for (const token of value) if (!Number.isInteger(token) || token < 0) throw new AIError("invalid_message", `${name} must contain token ids`);
+function now() {
+	return (/* @__PURE__ */ new Date()).toISOString();
 }
-function imageResult(value, model, fallbackMetadata) {
-	if (!isRecord(value) || typeof value.uri !== "string" || typeof value.width !== "number" || typeof value.height !== "number" || value.model !== model) throw new AIError("image_generation_failed", "Expected generated image URI");
-	const result = value;
-	const metadata = isRecord(result.metadata) ? result.metadata : {};
-	return {
-		uri: value.uri,
-		width: value.width,
-		height: value.height,
-		model,
-		metadata: {
-			...fallbackMetadata,
-			model: metadata.model === model ? model : fallbackMetadata.model,
-			width: typeof metadata.width === "number" ? metadata.width : value.width,
-			height: typeof metadata.height === "number" ? metadata.height : value.height,
-			steps: typeof metadata.steps === "number" ? metadata.steps : fallbackMetadata.steps,
-			guidance: typeof metadata.guidance === "number" ? metadata.guidance : fallbackMetadata.guidance,
-			strength: typeof metadata.strength === "number" ? metadata.strength : fallbackMetadata.strength,
-			seed: typeof metadata.seed === "number" ? metadata.seed : fallbackMetadata.seed,
-			elapsedMs: typeof metadata.elapsedMs === "number" ? metadata.elapsedMs : fallbackMetadata.elapsedMs,
-			appliedLoRAs: Array.isArray(metadata.appliedLoRAs) ? metadata.appliedLoRAs.flatMap((item) => {
-				if (!isRecord(item) || typeof item.path !== "string") return [];
-				return [{
-					id: typeof item.id === "string" ? item.id : void 0,
-					path: item.path,
-					scale: typeof item.scale === "number" ? item.scale : 1
-				}];
-			}) : fallbackMetadata.appliedLoRAs
+
+//#endregion
+//#region src/ai/image-models.ts
+const flux2Klein4B8BitAbliterated = {
+	formatVersion: 1,
+	model: "flux2-klein-4b-8bit-abliterated",
+	directory: "flux2-klein-4b-8bit-abliterated",
+	metadata: {
+		displayName: "Flux.2 Klein 4B Abliterated",
+		family: "flux2-klein",
+		precision: "8-bit",
+		estimatedMemoryGB: 12,
+		quality: "high",
+		speed: "fast",
+		capabilities: [
+			"text-to-image",
+			"image-to-image",
+			"inpainting",
+			"outpainting",
+			"references",
+			"lora"
+		]
+	},
+	components: {
+		textEncoder: {
+			repo: "mlx-community/Josiefied-Qwen3-4B-abliterated-v1-8bit",
+			revision: "main",
+			path: "text-encoder",
+			files: [
+				"config.json",
+				"tokenizer.json",
+				"tokenizer_config.json",
+				"*.safetensors",
+				"*.safetensors.index.json"
+			]
+		},
+		transformer: {
+			repo: "moxin-org/FLUX.2-klein-4B-8bit-mlx",
+			revision: "main",
+			path: "transformer",
+			files: ["config.json", "quantized_8bit.safetensors"]
+		},
+		vae: {
+			repo: "black-forest-labs/FLUX.2-klein-4B",
+			revision: "main",
+			path: "vae",
+			files: [
+				"config.json",
+				"diffusion_pytorch_model.safetensors",
+				"diffusion_pytorch_model.safetensors.index.json",
+				"diffusion_pytorch_model-*.safetensors"
+			]
 		}
-	};
+	}
+};
+const ternaryBonsaiImage4B = {
+	formatVersion: 1,
+	model: "ternary-bonsai-image-4b",
+	directory: "ternary-bonsai-image-4b",
+	metadata: {
+		displayName: "Ternary Bonsai Image 4B",
+		family: "bonsai-image",
+		precision: "2-bit",
+		estimatedMemoryGB: 8,
+		quality: "high",
+		speed: "fast",
+		capabilities: ["text-to-image"]
+	},
+	components: {
+		textEncoder: {
+			repo: "prism-ml/bonsai-image-ternary-4B-mlx-2bit",
+			revision: "2c24c81b934a658ba5590cf39088ba929985b4a8",
+			path: "text-encoder",
+			files: [
+				"text_encoder-mlx-4bit/config.json",
+				"text_encoder-mlx-4bit/tokenizer.json",
+				"text_encoder-mlx-4bit/tokenizer_config.json",
+				"text_encoder-mlx-4bit/model.safetensors",
+				"text_encoder-mlx-4bit/model.safetensors.index.json"
+			]
+		},
+		transformer: {
+			repo: "prism-ml/bonsai-image-ternary-4B-mlx-2bit",
+			revision: "2c24c81b934a658ba5590cf39088ba929985b4a8",
+			path: "transformer",
+			files: [
+				"transformer-packed-mflux/config.json",
+				"transformer-packed-mflux/diffusion_pytorch_model.safetensors",
+				"transformer-packed-mflux/quantization_config.json"
+			]
+		},
+		vae: {
+			repo: "prism-ml/bonsai-image-ternary-4B-mlx-2bit",
+			revision: "2c24c81b934a658ba5590cf39088ba929985b4a8",
+			path: "vae",
+			files: ["vae/config.json", "vae/diffusion_pytorch_model.safetensors"]
+		}
+	}
+};
+const imageModelManifests = [flux2Klein4B8BitAbliterated, ternaryBonsaiImage4B];
+function imageModelManifest(model) {
+	return imageModelManifests.find((manifest) => manifest.model === model);
 }
-async function withImageStage(stage, operation) {
-	try {
-		return await operation();
-	} catch (error) {
-		if (error instanceof ImageGenerationError) throw error;
-		if (error instanceof AIError && error.code === "generation_canceled") throw error;
-		throw new ImageGenerationError(stage, error instanceof Error ? error.message : String(error), error);
+const flux2KleinModelFiles = [
+	{
+		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
+		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
+		source: "config.json",
+		destination: "text-encoder/config.json",
+		bytes: 937
+	},
+	{
+		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
+		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
+		source: "tokenizer.json",
+		destination: "text-encoder/tokenizer.json",
+		bytes: 11422654
+	},
+	{
+		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
+		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
+		source: "tokenizer_config.json",
+		destination: "text-encoder/tokenizer_config.json",
+		bytes: 9706
+	},
+	{
+		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
+		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
+		source: "model.safetensors",
+		destination: "text-encoder/model.safetensors",
+		bytes: 4274158989
+	},
+	{
+		repo: flux2Klein4B8BitAbliterated.components.textEncoder.repo,
+		revision: flux2Klein4B8BitAbliterated.components.textEncoder.revision,
+		source: "model.safetensors.index.json",
+		destination: "text-encoder/model.safetensors.index.json",
+		bytes: 63924
+	},
+	{
+		repo: flux2Klein4B8BitAbliterated.components.transformer.repo,
+		revision: flux2Klein4B8BitAbliterated.components.transformer.revision,
+		source: "transformer/config.json",
+		destination: "transformer/config.json",
+		bytes: 541
+	},
+	{
+		repo: flux2Klein4B8BitAbliterated.components.transformer.repo,
+		revision: flux2Klein4B8BitAbliterated.components.transformer.revision,
+		source: "transformer/quantized_8bit.safetensors",
+		destination: "transformer/quantized_8bit.safetensors",
+		bytes: 4360050983
+	},
+	{
+		repo: flux2Klein4B8BitAbliterated.components.vae.repo,
+		revision: flux2Klein4B8BitAbliterated.components.vae.revision,
+		source: "vae/config.json",
+		destination: "vae/config.json",
+		bytes: 821
+	},
+	{
+		repo: flux2Klein4B8BitAbliterated.components.vae.repo,
+		revision: flux2Klein4B8BitAbliterated.components.vae.revision,
+		source: "vae/diffusion_pytorch_model.safetensors",
+		destination: "vae/diffusion_pytorch_model.safetensors",
+		bytes: 168120878
 	}
+];
+const flux2KleinTotalBytes = flux2KleinModelFiles.reduce((total, file) => total + file.bytes, 0);
+const bonsaiRepo = ternaryBonsaiImage4B.components.textEncoder.repo;
+const bonsaiRevision = ternaryBonsaiImage4B.components.textEncoder.revision;
+const ternaryBonsaiImageModelFiles = [
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "text_encoder-mlx-4bit/config.json",
+		destination: "text-encoder/config.json",
+		bytes: 937
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "text_encoder-mlx-4bit/tokenizer.json",
+		destination: "text-encoder/tokenizer.json",
+		bytes: 11422654
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "text_encoder-mlx-4bit/tokenizer_config.json",
+		destination: "text-encoder/tokenizer_config.json",
+		bytes: 9706
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "text_encoder-mlx-4bit/model.safetensors",
+		destination: "text-encoder/model.safetensors",
+		bytes: 2263022529
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "text_encoder-mlx-4bit/model.safetensors.index.json",
+		destination: "text-encoder/model.safetensors.index.json",
+		bytes: 63924
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "transformer-packed-mflux/config.json",
+		destination: "transformer/config.json",
+		bytes: 619
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "transformer-packed-mflux/diffusion_pytorch_model.safetensors",
+		destination: "transformer/diffusion_pytorch_model.safetensors",
+		bytes: 1425271472
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "transformer-packed-mflux/quantization_config.json",
+		destination: "transformer/quantization_config.json",
+		bytes: 5054
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "vae/config.json",
+		destination: "vae/config.json",
+		bytes: 821
+	},
+	{
+		repo: bonsaiRepo,
+		revision: bonsaiRevision,
+		source: "vae/diffusion_pytorch_model.safetensors",
+		destination: "vae/diffusion_pytorch_model.safetensors",
+		bytes: 168120878
+	}
+];
+const ternaryBonsaiImageTotalBytes = ternaryBonsaiImageModelFiles.reduce((total, file) => total + file.bytes, 0);
+function joinModelPath(root, component) {
+	return `${root.replace(/\/+$/, "")}/${component.replace(/^\/+/, "")}`;
 }
-function imagegenProgress(value) {
-	const currentStep = value.currentStep;
-	const totalSteps = value.totalSteps;
-	if (typeof currentStep !== "number" || !Number.isFinite(currentStep) || typeof totalSteps !== "number" || !Number.isFinite(totalSteps) || totalSteps <= 0) return;
+function fluxImageModelPaths(path, manifest = flux2Klein4B8BitAbliterated) {
 	return {
-		currentStep,
-		totalSteps,
-		fraction: Math.max(0, Math.min(1, currentStep / totalSteps))
+		path,
+		textEncoderPath: joinModelPath(path, manifest.components.textEncoder.path),
+		transformerPath: joinModelPath(path, manifest.components.transformer.path),
+		vaePath: joinModelPath(path, manifest.components.vae.path)
 	};
 }
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw new AIError("generation_canceled", "Image generation canceled");
-}
-function nativeErrorStage(error) {
-	const stage = (error instanceof Error ? error.message : String(error)).match(/^\[(download|tokenize|encode|denoise|decode|write)]\s/)?.[1] ?? (isRecord(error) && typeof error.stage === "string" ? error.stage : isRecord(error) && isRecord(error.userInfo) && typeof error.userInfo.stage === "string" ? error.userInfo.stage : void 0);
-	return stage === "download" || stage === "tokenize" || stage === "encode" || stage === "denoise" || stage === "decode" || stage === "write" ? stage : void 0;
+
+//#endregion
+//#region src/ai/image-schedule.ts
+function imageSigmaSchedule(schedules) {
+	const configured = schedules.filter((schedule) => schedule !== void 0);
+	if (configured.length === 0) return void 0;
+	const first = configured[0];
+	if (first.length === 0 || first.some((sigma, index) => !Number.isFinite(sigma) || sigma <= 0 || sigma > 1 || index > 0 && sigma >= first[index - 1])) throw new AIError("invalid_model", "LoRA sigmaSchedule must contain descending values greater than 0 and at most 1");
+	if (configured.some((schedule) => schedule.length !== first.length || schedule.some((sigma, index) => sigma !== first[index]))) throw new AIError("invalid_model", "Selected LoRAs require conflicting sigma schedules");
+	return [...first];
 }
-function nativeErrorMessage(error) {
-	return (error instanceof Error ? error.message : String(error)).replace(/^\[(download|tokenize|encode|denoise|decode|write)]\s*/, "");
+
+//#endregion
+//#region src/ai/image-upscale.ts
+function normalizeUpscaleScale(value) {
+	const scale = value ?? 2;
+	if (!Number.isFinite(scale) || scale <= 1 || scale > 4) throw new AIError("invalid_model", "Upscale scale must be greater than 1 and at most 4");
+	return scale;
 }
-async function prepareImageModel(options = {}) {
-	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
-	return prepareImageModelAtPath(definition, options, options.directory ? require_files.files.directory(options.directory, definition.manifest.directory).path : modelCacheRoot(definition.manifest).path);
+
+//#endregion
+//#region src/ai/image.ts
+function imageModelId(model) {
+	return typeof model === "string" ? model : model.id;
 }
-async function prepareImageModelAtPath(definition, options, path) {
-	const model = definition.manifest.model;
-	const root = require_files.files.directory(path);
-	await root.create({ recursive: true });
-	const headers = options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0;
-	const total = definition.files.length;
-	const bytesByFile = /* @__PURE__ */ new Map();
-	const emitProgress = (progress) => {
-		const file = definition.files.find((candidate) => candidate.destination === progress.file);
-		const bytesWritten = file ? Math.min(progress.bytesWritten, file.bytes) : progress.bytesWritten;
-		bytesByFile.set(progress.file, bytesWritten);
-		const modelBytesWritten = Array.from(bytesByFile.values()).reduce((sum, bytes) => sum + bytes, 0);
-		options.onProgress?.({
-			...progress,
-			bytesWritten,
-			modelBytesWritten,
-			totalModelBytes: definition.totalBytes,
-			modelFraction: modelBytesWritten / definition.totalBytes
-		});
+function imageModelDefinition(model) {
+	const id = imageModelId(model);
+	if (id === flux2Klein4B8BitAbliterated.model) return {
+		manifest: flux2Klein4B8BitAbliterated,
+		files: flux2KleinModelFiles,
+		totalBytes: flux2KleinTotalBytes
 	};
-	const missingFiles = [];
-	for (const [index, file] of definition.files.entries()) {
-		const stat = await require_files.files.file(root.path, file.destination).stat();
-		if (stat.type === "file" && stat.size === file.bytes) emitProgress({
-			model,
-			file: file.destination,
-			index: index + 1,
-			total,
-			bytesWritten: file.bytes,
-			totalBytes: file.bytes,
-			fraction: 1
-		});
-		else missingFiles.push({
-			file,
-			index: index + 1
-		});
-	}
-	await runConcurrent(missingFiles, downloadConcurrency(options.concurrency), async ({ file, index }) => {
-		await ensureModelFile({
-			model,
-			path: root.path,
-			file,
-			headers,
-			index,
-			total,
-			onProgress: emitProgress
-		});
-	});
-	await writePreparedManifest(root.path, definition.manifest);
-	return {
-		model,
-		...fluxImageModelPaths(root.path, definition.manifest),
-		tokenizer: await createFluxTokenizer(root.path, definition.manifest)
+	if (id === ternaryBonsaiImage4B.model) return {
+		manifest: ternaryBonsaiImage4B,
+		files: ternaryBonsaiImageModelFiles,
+		totalBytes: ternaryBonsaiImageTotalBytes
 	};
+	throw new AIError("invalid_model", `Unsupported image model: ${id}`);
 }
-async function verifyImageModel(options = {}) {
-	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
-	return imageModelState(definition.manifest.model, modelPathFromOptions(definition, options.path));
-}
-async function listImageModels(options = {}) {
-	return [...await Promise.all([flux2Klein4B8BitAbliterated.model, ternaryBonsaiImage4B.model].map((model) => {
-		const definition = imageModelDefinition(model);
-		return imageModelState(model, options.directory ? require_files.files.directory(options.directory, definition.manifest.directory).path : modelPathFromOptions(definition, void 0));
-	}))];
+function modelCacheRoot(manifest) {
+	return require_files.files.directory(require_files.files.paths.models, manifest.directory);
 }
-async function deleteImageModel(options = {}) {
-	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
-	await require_files.files.directory(modelPathFromOptions(definition, options.path)).delete({ recursive: true });
+function assertImageModel(model) {
+	imageModelDefinition(model);
 }
-async function imageMemoryTelemetry() {
-	const value = await bridge().imageMemoryTelemetry?.();
-	if (!value) throw new AIError("image_generation_failed", "Image service is unavailable");
-	return value;
+function modelPathFromOptions(definition, path) {
+	return path ?? modelCacheRoot(definition.manifest).path;
 }
-async function unloadImageModel() {
-	return await bridge().unloadImageModel?.() ?? false;
+function downloadConcurrency(value) {
+	if (value === void 0) return 2;
+	if (!Number.isInteger(value)) throw new AIError("invalid_model", "concurrency must be an integer");
+	return Math.min(4, Math.max(1, value));
 }
-async function upscaleImage(options) {
-	throwIfAborted(options.signal);
-	const scale = normalizeUpscaleScale(options.scale);
-	const value = await bridge().upscaleImage?.({
-		imagePath: filePathFromUri(options.image, "image"),
-		scale
+async function runConcurrent(items, concurrency, worker) {
+	let nextIndex = 0;
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+		while (nextIndex < items.length) {
+			const item = items[nextIndex];
+			nextIndex += 1;
+			await worker(item);
+		}
 	});
-	throwIfAborted(options.signal);
-	if (!value || typeof value.uri !== "string" || !Number.isInteger(value.width) || !Number.isInteger(value.height) || value.scale !== scale) throw new AIError("image_generation_failed", "Native image upscaling returned an invalid result");
-	return value;
+	await Promise.all(workers);
 }
-async function prepareImageLoRA(lora, options = {}) {
-	assertLoRADefinition(lora);
-	const resolvedDefinition = await resolveHuggingFaceLoRA(lora, options);
-	const id = safeCacheName(lora.id, "lora.id");
-	const scale = assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
-	if (resolvedDefinition.source.type === "local") {
-		const path = filePathFromUri(resolvedDefinition.source.path, `lora ${id}`);
-		const stat$1 = await require_files.files.file(path).stat();
-		if (stat$1.type !== "file") throw new AIError("invalid_model", `Missing LoRA file: ${path}`);
-		if (!hasSafetensorsHeader(stat$1.size)) throw new AIError("invalid_model", `Invalid LoRA safetensors file: ${path}`);
-		return {
-			id: lora.id,
-			description: lora.description,
-			path,
-			uri: stat$1.uri,
-			scale,
-			source: resolvedDefinition.source,
-			metadata: lora.metadata
-		};
-	}
-	const url = loraUrl(resolvedDefinition);
-	if (!url) throw new AIError("invalid_model", `Unsupported LoRA source: ${lora.id}`);
-	const root = imageLoRARoot().directory(id);
-	await root.create({ recursive: true });
-	const destination = root.file(safeCacheName(sourceFileName(resolvedDefinition), "lora filename"));
-	const expectedBytes = loraExpectedBytes(resolvedDefinition);
-	const stat = await destination.stat();
-	if (stat.type !== "file" || !hasSafetensorsHeader(stat.size) || expectedBytes !== void 0 && stat.size !== expectedBytes) await destination.download(url, {
-		headers: loraHeaders(resolvedDefinition, options.accessToken),
-		expectedBytes,
-		atomic: true,
-		resume: true,
-		signal: options.signal,
-		onProgress(progress) {
-			options.onProgress?.({
-				lora: lora.id,
-				file: destination.path,
-				bytesWritten: progress.bytesWritten,
-				totalBytes: progress.totalBytes,
-				fraction: progress.fraction
-			});
-		}
-	}).result;
-	await root.file("manifest.json").write(JSON.stringify({
-		formatVersion: 1,
-		id: lora.id,
-		file: destination.path.split("/").pop(),
-		source: resolvedDefinition.source,
-		metadata: lora.metadata
-	}, null, 2));
-	const preparedStat = await destination.stat();
-	if (preparedStat.type !== "file" || !hasSafetensorsHeader(preparedStat.size)) throw new AIError("invalid_model", `Invalid LoRA safetensors file: ${destination.path}`);
-	return {
-		id: lora.id,
-		description: lora.description,
-		path: destination.path,
-		uri: preparedStat.uri,
-		scale,
-		source: resolvedDefinition.source,
-		metadata: lora.metadata
-	};
+function hfResolveUrl(repo, revision, path) {
+	const encodedRepo = repo.split("/").map(encodeURIComponent).join("/");
+	const encodedPath = path.split("/").map(encodeURIComponent).join("/");
+	return `https://huggingface.co/${encodedRepo}/resolve/${encodeURIComponent(revision)}/${encodedPath}`;
 }
-async function verifyImageLoRA(lora) {
-	assertLoRADefinition(lora);
-	const scale = assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
-	let resolvedDefinition = lora;
-	if (lora.source.type === "huggingface" && !lora.source.path) {
-		const manifestFile = imageLoRARoot().directory(safeCacheName(lora.id, "lora.id")).file("manifest.json");
-		if ((await manifestFile.stat()).type === "file") {
-			const manifest = await manifestFile.json();
-			if (isRecord(manifest) && isRecord(manifest.source) && manifest.source.type === "huggingface" && manifest.source.repo === lora.source.repo && (manifest.source.revision ?? "main") === (lora.source.revision ?? "main") && typeof manifest.source.path === "string") resolvedDefinition = {
-				...lora,
-				source: {
-					...lora.source,
-					path: manifest.source.path,
-					revision: typeof manifest.source.revision === "string" ? manifest.source.revision : lora.source.revision,
-					bytes: typeof manifest.source.bytes === "number" ? manifest.source.bytes : lora.source.bytes
-				}
-			};
-		}
-	}
-	const file = resolvedDefinition.source.type === "local" ? require_files.files.file(filePathFromUri(resolvedDefinition.source.path, `lora ${lora.id}`)) : cachedLoRAFile(resolvedDefinition);
-	const stat = await file.stat();
-	const expectedBytes = loraExpectedBytes(resolvedDefinition);
-	const installed = stat.type === "file";
-	const verified = installed && hasSafetensorsHeader(stat.size) && (expectedBytes === void 0 || stat.size === expectedBytes);
+const imageDimensionMultiple = 16;
+const minimumImageDimension = 64;
+const defaultImageLongSide = 1152;
+const aspectRatioValues = {
+	"1:1": [1, 1],
+	"16:9": [16, 9],
+	"9:16": [9, 16],
+	"4:3": [4, 3],
+	"3:2": [3, 2],
+	"2:3": [2, 3],
+	"21:9": [21, 9]
+};
+function normalizedDimension(value) {
+	return Math.max(minimumImageDimension, Math.floor(value / imageDimensionMultiple) * imageDimensionMultiple);
+}
+function normalizeImageSize(size, maxLongSide = defaultImageLongSide) {
+	if (!Number.isFinite(size.width) || size.width <= 0) throw new AIError("invalid_model", "size.width must be positive");
+	if (!Number.isFinite(size.height) || size.height <= 0) throw new AIError("invalid_model", "size.height must be positive");
+	if (maxLongSide !== false && (!Number.isInteger(maxLongSide) || maxLongSide < minimumImageDimension)) throw new AIError("invalid_model", `maxLongSide must be false or an integer of at least ${minimumImageDimension}`);
+	const scale = maxLongSide === false ? 1 : Math.min(1, maxLongSide / Math.max(size.width, size.height));
 	return {
-		id: lora.id,
-		description: lora.description,
-		path: file.path,
-		uri: stat.uri,
-		scale,
-		source: resolvedDefinition.source,
-		metadata: lora.metadata,
-		installed,
-		verified,
-		size: stat.size
+		width: normalizedDimension(size.width * scale),
+		height: normalizedDimension(size.height * scale)
 	};
 }
-async function listImageLoRAs(loras) {
-	return Promise.all(loras.map((lora) => verifyImageLoRA(lora)));
+function imageSizeForPreset(aspectRatio, maxLongSide = defaultImageLongSide) {
+	const ratio = aspectRatioValues[aspectRatio];
+	if (!ratio) throw new AIError("invalid_model", `Unsupported image aspect ratio: ${aspectRatio}`);
+	assertPositiveInteger(maxLongSide, "maxLongSide");
+	const [widthRatio, heightRatio] = ratio;
+	return normalizeImageSize(widthRatio >= heightRatio ? {
+		width: maxLongSide,
+		height: maxLongSide * heightRatio / widthRatio
+	} : {
+		width: maxLongSide * widthRatio / heightRatio,
+		height: maxLongSide
+	}, maxLongSide);
+}
+function imageLoRARoot() {
+	return require_files.files.directory(require_files.files.paths.models, "image-loras");
 }
-async function deleteImageLoRA(lora) {
-	const id = safeCacheName(typeof lora === "string" ? lora : lora.id, "lora.id");
-	await imageLoRARoot().directory(id).delete({ recursive: true });
+function safeCacheName(value, name) {
+	const trimmed = value.trim();
+	if (!trimmed) throw new AIError("invalid_model", `${name} must not be empty`);
+	return trimmed.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-async function prepareSelectedImageLoRAs(loras, model, options = {}) {
-	const prepared = [];
-	for (const lora of loras) {
-		assertLoRADefinition(lora);
-		assertLoRACompatibility(lora, model);
-		prepared.push(await prepareImageLoRA(lora, options));
-	}
-	return prepared;
+function sourceFileName(lora) {
+	if (lora.source.type === "local") return lora.source.path.split("/").pop() || `${lora.id}.safetensors`;
+	if (lora.source.type === "url") return lora.source.filename ?? lora.source.url.split("/").pop() ?? `${lora.id}.safetensors`;
+	return lora.source.path?.split("/").pop() || `${lora.id}.safetensors`;
 }
-async function generateImage(options) {
-	throwIfAborted(options.signal);
-	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
-	const model = definition.manifest.model;
-	const prompt = options.prompt.trim();
-	if (!prompt) throw new AIError("invalid_message", "Expected prompt");
-	const presetSize = options.aspectRatio ? imageSizeForPreset(options.aspectRatio) : void 0;
-	const requestedSize = normalizeImageSize({
-		width: options.width ?? presetSize?.width ?? 1024,
-		height: options.height ?? presetSize?.height ?? 1024
-	}, false);
-	const width = requestedSize.width;
-	const height = requestedSize.height;
-	const outpaintSize = options.outpaint ? normalizeImageSize({
-		width: options.outpaint.width,
-		height: options.outpaint.height
-	}, false) : void 0;
-	if (options.outpaint && (outpaintSize?.width !== options.outpaint.width || outpaintSize?.height !== options.outpaint.height)) throw new AIError("invalid_model", "outpaint width and height must be multiples of 16");
-	const steps = options.steps ?? 4;
-	const guidance = options.guidance ?? 1;
-	const seed = options.seed ?? Math.floor(Math.random() * 4294967296);
-	const sourceImagePath = options.image ? filePathFromUri(options.image, "image") : void 0;
-	const maskImagePath = options.mask ? filePathFromUri(options.mask, "mask") : void 0;
-	const referenceImagePaths = (options.references ?? []).map((reference, index) => filePathFromUri(reference, `references[${index}]`));
-	const isImageConditioned = Boolean(sourceImagePath) || referenceImagePaths.length > 0;
-	const strength = options.strength ?? (isImageConditioned ? .8 : void 0);
-	if (maskImagePath && !sourceImagePath) throw new AIError("invalid_message", "mask requires image");
-	if (options.maskMode !== void 0 && options.maskMode !== "paint" && options.maskMode !== "preserve") throw new AIError("invalid_model", "maskMode must be paint or preserve");
-	if (options.outpaint && !sourceImagePath) throw new AIError("invalid_message", "outpaint requires image");
-	if (options.outpaint) {
-		assertPositiveInteger(options.outpaint.width, "outpaint.width");
-		assertPositiveInteger(options.outpaint.height, "outpaint.height");
-		const rect = options.outpaint.sourceRect;
-		if (!rect) throw new AIError("invalid_model", "outpaint.sourceRect is required");
-		assertPositiveInteger(rect.width, "outpaint.sourceRect.width");
-		assertPositiveInteger(rect.height, "outpaint.sourceRect.height");
-		if (!Number.isInteger(rect.x) || !Number.isInteger(rect.y)) throw new AIError("invalid_model", "outpaint.sourceRect x and y must be integers");
-		const canvasWidth = outpaintSize?.width ?? options.outpaint.width;
-		const canvasHeight = outpaintSize?.height ?? options.outpaint.height;
-		if (!(rect.x < canvasWidth && rect.y < canvasHeight && rect.x + rect.width > 0 && rect.y + rect.height > 0)) throw new AIError("invalid_model", "outpaint.sourceRect must intersect the canvas");
-		if (!options.outpaint.autoCrop && (rect.x < 0 || rect.y < 0 || rect.x + rect.width > canvasWidth || rect.y + rect.height > canvasHeight)) throw new AIError("invalid_model", "outpaint.sourceRect must fit within the outpaint canvas");
-	}
-	if (options.resizeMode !== void 0 && options.resizeMode !== "stretch" && options.resizeMode !== "fit" && options.resizeMode !== "crop") throw new AIError("invalid_model", "resizeMode must be stretch, fit, or crop");
-	if (options.maxInputLongSide !== void 0 && options.maxInputLongSide !== false && (!Number.isInteger(options.maxInputLongSide) || options.maxInputLongSide < 64)) throw new AIError("invalid_model", "maxInputLongSide must be false or an integer of at least 64");
-	assertPositiveInteger(width, "width");
-	assertPositiveInteger(height, "height");
-	assertPositiveInteger(steps, "steps");
-	if (seed !== void 0 && (!Number.isInteger(seed) || seed < 0)) throw new AIError("invalid_model", "seed must be a non-negative integer");
-	if (!Number.isFinite(guidance) || guidance <= 0) throw new AIError("invalid_model", "guidance must be a positive number");
-	if (referenceImagePaths.length > 3) throw new AIError("invalid_model", "references must contain at most 3 images");
-	if (options.referenceInfluences !== void 0) {
-		if (options.referenceInfluences.length !== referenceImagePaths.length) throw new AIError("invalid_model", "referenceInfluences must match references length");
-		for (const [index, influence] of options.referenceInfluences.entries()) if (!Number.isFinite(influence) || influence < 0) throw new AIError("invalid_model", `referenceInfluences[${index}] must be a non-negative number`);
+function assertLoRAScale(scale, name = "lora.scale") {
+	const value = scale ?? 1;
+	if (!Number.isFinite(value) || value <= 0) throw new AIError("invalid_model", `${name} must be a positive number`);
+	return value;
+}
+function assertLoRADefinition(lora) {
+	safeCacheName(lora.id, "lora.id");
+	assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
+	imageSigmaSchedule([lora.metadata?.sigmaSchedule]);
+	if (lora.metadata?.baseModel !== void 0) assertImageModel(lora.metadata.baseModel);
+	if (lora.metadata?.precision !== void 0 && ![
+		"float16",
+		"bfloat16",
+		"float32"
+	].includes(lora.metadata.precision)) throw new AIError("invalid_model", "lora.metadata.precision is unsupported");
+}
+function assertLoRACompatibility(lora, model) {
+	if (lora.metadata?.baseModel && lora.metadata.baseModel !== model) throw new AIError("invalid_model", `LoRA ${lora.id} targets ${lora.metadata.baseModel}, not ${model}`);
+}
+const commonLoRAFileNames = [
+	"pytorch_lora_weights.safetensors",
+	"adapter_model.safetensors",
+	"lora.safetensors",
+	"model.safetensors"
+];
+async function resolveHuggingFaceLoRA(lora, options) {
+	if (lora.source.type !== "huggingface" || lora.source.path) return lora;
+	const revision = lora.source.revision ?? "main";
+	const manifestFile = imageLoRARoot().directory(safeCacheName(lora.id, "lora.id")).file("manifest.json");
+	if ((await manifestFile.stat()).type === "file") {
+		const manifest = await manifestFile.json();
+		if (isRecord(manifest) && isRecord(manifest.source) && manifest.source.type === "huggingface" && manifest.source.repo === lora.source.repo && (manifest.source.revision ?? "main") === revision && typeof manifest.source.path === "string") return {
+			...lora,
+			source: {
+				...lora.source,
+				revision,
+				path: manifest.source.path,
+				bytes: lora.source.bytes ?? (typeof manifest.source.bytes === "number" ? manifest.source.bytes : void 0)
+			}
+		};
 	}
-	if (strength !== void 0) assertUnitInterval(strength, "strength");
-	const selectedLoRAs = options.loras?.length ? await withImageStage("download", () => prepareSelectedImageLoRAs(options.loras ?? [], model, {
-		accessToken: options.accessToken,
+	const encodedRepo = lora.source.repo.split("/").map(encodeURIComponent).join("/");
+	const response = await fetch(`https://huggingface.co/api/models/${encodedRepo}/revision/${encodeURIComponent(revision)}`, {
+		headers: options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0,
 		signal: options.signal
-	})) : [];
-	const sigmaSchedule = imageSigmaSchedule(selectedLoRAs.map((lora) => lora.metadata?.sigmaSchedule));
-	if (sigmaSchedule && options.steps !== void 0 && options.steps !== sigmaSchedule.length) throw new AIError("invalid_model", `steps must equal the LoRA sigma schedule length (${sigmaSchedule.length})`);
-	const generationSteps = sigmaSchedule?.length ?? steps;
-	const prepared = options.path && options.tokenizer ? void 0 : await withImageStage("download", () => prepareImageModelAtPath(definition, {
-		model,
-		accessToken: options.accessToken,
-		concurrency: options.concurrency,
-		onProgress: options.onModelProgress
-	}, options.path ?? modelCacheRoot(definition.manifest).path));
-	throwIfAborted(options.signal);
-	const tokenizer = options.tokenizer ?? prepared?.tokenizer;
-	const modelPath = options.path ?? prepared?.path;
-	if (!tokenizer || !modelPath) throw new AIError("invalid_model", "Expected image model path and tokenizer");
-	const tokenized = await withImageStage("tokenize", () => tokenizer({
-		prompt,
-		maxLength: 512
-	}));
-	throwIfAborted(options.signal);
-	await withImageStage("tokenize", () => {
-		assertTokenArray(tokenized.inputIds, "inputIds");
-		assertTokenArray(tokenized.attentionMask, "attentionMask");
-		if (tokenized.inputIds.length !== tokenized.attentionMask.length) throw new AIError("invalid_message", "inputIds and attentionMask must have the same length");
 	});
-	const paths = fluxImageModelPaths(modelPath, definition.manifest);
-	const request = {
-		model,
-		prompt,
-		sourceImagePath,
-		maskImagePath,
-		maskMode: options.maskMode,
-		outpaintWidth: outpaintSize?.width,
-		outpaintHeight: outpaintSize?.height,
-		outpaintSourceX: options.outpaint?.sourceRect.x,
-		outpaintSourceY: options.outpaint?.sourceRect.y,
-		outpaintSourceWidth: options.outpaint?.sourceRect.width,
-		outpaintSourceHeight: options.outpaint?.sourceRect.height,
-		outpaintAutoCrop: options.outpaint?.autoCrop,
-		resizeMode: options.resizeMode,
-		maxInputLongSide: options.maxInputLongSide === false ? 0 : options.maxInputLongSide ?? defaultImageLongSide,
-		referenceImagePaths,
-		referenceInfluences: options.referenceInfluences,
-		loraPaths: selectedLoRAs.map((lora) => lora.path),
-		loraScales: selectedLoRAs.map((lora) => lora.scale),
-		loraIds: selectedLoRAs.map((lora) => lora.id),
-		sigmaSchedule,
-		width,
-		height,
-		steps: generationSteps,
-		guidance,
-		strength,
-		seed,
-		inputIds: tokenized.inputIds,
-		attentionMask: tokenized.attentionMask,
-		modelRoot: paths.path,
-		textEncoderPath: paths.textEncoderPath,
-		transformerPath: paths.transformerPath,
-		vaePath: paths.vaePath
-	};
-	const fallbackMetadata = {
-		model,
-		width: outpaintSize?.width ?? width,
-		height: outpaintSize?.height ?? height,
-		steps: generationSteps,
-		guidance,
-		strength,
-		seed,
-		appliedLoRAs: selectedLoRAs.map((lora) => ({
-			id: lora.id,
-			path: lora.path,
-			scale: lora.scale
-		})),
-		sigmaSchedule
-	};
-	try {
-		const native = bridge();
-		const cancelNative = () => {
-			native.cancelImagegen?.();
-		};
-		const subscription = options.onProgress ? native.addListener?.("imagegenProgress", (event) => {
-			const progress = imagegenProgress(event);
-			if (progress) options.onProgress?.(progress);
-		}) : void 0;
-		try {
-			options.signal?.addEventListener("abort", cancelNative, { once: true });
-			throwIfAborted(options.signal);
-			const value = await native.generateImage?.(request);
-			throwIfAborted(options.signal);
-			return imageResult(value, model, fallbackMetadata);
-		} finally {
-			subscription?.remove();
-			options.signal?.removeEventListener("abort", cancelNative);
-		}
-	} catch (error) {
-		if (error instanceof ImageGenerationError) throw error;
-		if (error instanceof AIError) throw error;
-		if (options.signal?.aborted) throw new AIError("generation_canceled", "Image generation canceled", error);
-		const mapped = mapNativeError(error);
-		if (mapped.code === "generation_failed" || mapped.code === "image_generation_failed") throw new ImageGenerationError(nativeErrorStage(error) ?? "denoise", nativeErrorMessage(error), error);
-		throw mapped;
-	}
-}
-async function generateImages(options) {
-	const { count,...imageOptions } = options;
-	const results = [];
-	for (const seed of batchImageSeeds(count, options.seed)) {
-		throwIfAborted(options.signal);
-		results.push(await generateImage({
-			...imageOptions,
-			seed
-		}));
+	if (!response.ok) throw new AIError("invalid_model", `Unable to inspect Hugging Face LoRA ${lora.source.repo}: ${response.status}`);
+	const value = await response.json();
+	const siblings = isRecord(value) && Array.isArray(value.siblings) ? value.siblings.flatMap((item) => {
+		if (!isRecord(item) || typeof item.rfilename !== "string") return [];
+		return [{
+			path: item.rfilename,
+			bytes: typeof item.size === "number" ? item.size : void 0
+		}];
+	}) : [];
+	const common = commonLoRAFileNames.map((name) => siblings.find((file) => file.path === name)).find(Boolean);
+	const safetensors = siblings.filter((file) => file.path.endsWith(".safetensors"));
+	const selected = common ?? (safetensors.length === 1 ? safetensors[0] : void 0);
+	if (!selected) {
+		const candidates = safetensors.map((file) => file.path).join(", ");
+		throw new AIError("invalid_model", candidates ? `Multiple LoRA weights found for ${lora.id}; set source.path to one of: ${candidates}` : `No .safetensors LoRA weight found for ${lora.id}`);
 	}
-	return results;
-}
-const imageGenerationQueueKey = Symbol.for("bleam.ai.imageGenerationQueue");
-function imageGenerationQueue() {
-	const scope = globalThis;
-	const queue = scope[imageGenerationQueueKey] ?? new ImageGenerationQueue(generateImage);
-	queue.setExecutor(generateImage);
-	scope[imageGenerationQueueKey] = queue;
-	return queue;
+	return {
+		...lora,
+		source: {
+			...lora.source,
+			revision,
+			path: selected.path,
+			bytes: lora.source.bytes ?? selected.bytes
+		}
+	};
 }
-function scheduleImageGeneration(options) {
-	return imageGenerationQueue().schedule(options);
+function loraUrl(lora) {
+	if (lora.source.type === "url") return lora.source.url;
+	if (lora.source.type === "huggingface") {
+		if (!lora.source.path) return void 0;
+		return hfResolveUrl(lora.source.repo, lora.source.revision ?? "main", lora.source.path);
+	}
 }
-function getImageGenerationJob(id) {
-	return imageGenerationQueue().get(id);
+function loraExpectedBytes(lora) {
+	return lora.source.type === "local" ? void 0 : lora.source.bytes;
 }
-function listImageGenerationJobs() {
-	return imageGenerationQueue().list();
+function hasSafetensorsHeader(size) {
+	return size !== void 0 && size > 8;
 }
-
-//#endregion
-//#region src/ai/image-composer.tsx
-const defaultImageSize = defaultImageLongSide;
-const defaultStepCount = 4;
-const minOutpaintScale = .35;
-const maxOutpaintScale = .95;
-function roundImageDimension(value) {
-	return normalizeImageSize({
-		width: value,
-		height: value
-	}, false).width;
+function loraHeaders(lora, accessToken) {
+	return lora.source.type === "huggingface" && accessToken ? { Authorization: `Bearer ${accessToken}` } : void 0;
 }
-function imageSizeForAspectRatio(size, maxSide = defaultImageSize) {
-	if (size.width <= 0 || size.height <= 0) return {
-		width: maxSide,
-		height: maxSide
-	};
-	const aspect = size.width / size.height;
-	return normalizeImageSize({
-		width: aspect >= 1 ? maxSide : maxSide * aspect,
-		height: aspect >= 1 ? maxSide / aspect : maxSide
-	}, maxSide);
+function cachedLoRAFile(lora) {
+	const id = safeCacheName(lora.id, "lora.id");
+	return imageLoRARoot().directory(id).file(safeCacheName(sourceFileName(lora), "lora filename"));
 }
-function roundedImageSize(size) {
-	return normalizeImageSize(size);
+async function ensureModelFile(input) {
+	const destination = require_files.files.file(input.path, input.file.destination);
+	const stat = await destination.stat();
+	if (stat.type === "file" && stat.size === input.file.bytes) {
+		input.onProgress?.({
+			model: input.model,
+			file: input.file.destination,
+			index: input.index,
+			total: input.total,
+			bytesWritten: input.file.bytes,
+			totalBytes: input.file.bytes,
+			fraction: 1
+		});
+		return;
+	}
+	await destination.download(hfResolveUrl(input.file.repo, input.file.revision, input.file.source), {
+		headers: input.headers,
+		expectedBytes: input.file.bytes,
+		atomic: true,
+		resume: true,
+		onProgress(progress) {
+			input.onProgress?.({
+				model: input.model,
+				file: input.file.destination,
+				index: input.index,
+				total: input.total,
+				...progress
+			});
+		}
+	}).result;
 }
-function clamp(value, min$1, max) {
-	return Math.min(max, Math.max(min$1, value));
+async function writePreparedManifest(path, manifest) {
+	await require_files.files.file(path, "manifest.json").write(JSON.stringify(manifest, null, 2));
 }
-function clampOutpaintRect(rect) {
-	const width = Math.min(defaultImageSize, Math.max(1, Math.round(rect.width)));
-	const height = Math.min(defaultImageSize, Math.max(1, Math.round(rect.height)));
+async function imageModelState(model, path) {
+	const definition = imageModelDefinition(model);
+	let bytesPresent = 0;
+	const missingFiles = [];
+	const invalidFiles = [];
+	for (const file of definition.files) {
+		const stat = await require_files.files.file(path, file.destination).stat();
+		if (stat.type !== "file") {
+			missingFiles.push(file.destination);
+			continue;
+		}
+		bytesPresent += Math.min(stat.size ?? 0, file.bytes);
+		if (stat.size !== file.bytes) invalidFiles.push(file.destination);
+	}
+	const manifestStat = await require_files.files.file(path, "manifest.json").stat();
+	if (manifestStat.type !== "file") missingFiles.push("manifest.json");
+	const installed = missingFiles.length === 0;
 	return {
-		x: Math.round(clamp(rect.x, 0, defaultImageSize - width)),
-		y: Math.round(clamp(rect.y, 0, defaultImageSize - height)),
-		width,
-		height
+		model,
+		path,
+		paths: fluxImageModelPaths(path, definition.manifest),
+		installed,
+		verified: installed && invalidFiles.length === 0 && manifestStat.type === "file",
+		bytesPresent,
+		totalBytes: definition.totalBytes,
+		missingFiles,
+		invalidFiles
 	};
 }
-function rectForSourceScale(sourceSize, scale, center) {
-	const aspect = sourceSize.width / sourceSize.height;
-	const longSide = defaultImageSize * clamp(scale, minOutpaintScale, maxOutpaintScale);
-	const width = aspect >= 1 ? longSide : longSide * aspect;
-	const height = aspect >= 1 ? longSide / aspect : longSide;
-	const nextCenter = center ?? {
-		x: defaultImageSize / 2,
-		y: defaultImageSize / 2
-	};
-	return clampOutpaintRect({
-		x: nextCenter.x - width / 2,
-		y: nextCenter.y - height / 2,
-		width,
-		height
+function tokenArray(value, name) {
+	const candidate = isRecord(value) && "data" in value ? value.data : value;
+	const values = Array.isArray(candidate) ? candidate : ArrayBuffer.isView(candidate) ? Array.from(candidate) : void 0;
+	if (!values) throw new AIError("invalid_message", `Tokenizer did not return ${name}`);
+	return values.map((token) => {
+		const number$1 = typeof token === "bigint" ? Number(token) : token;
+		if (!Number.isInteger(number$1) || number$1 < 0) throw new AIError("invalid_message", `${name} must contain token ids`);
+		return number$1;
 	});
 }
-function initialOutpaintRect(sourceSize) {
-	return rectForSourceScale(sourceSize, .72);
-}
-function buildImageGenerationRequest(input, options = {}) {
-	const base = {
-		prompt: input.prompt,
-		mode: input.mode,
-		steps: defaultStepCount,
-		guidance: 1,
-		...options
-	};
-	if (input.mode === "text") {
-		const references = (input.refs ?? []).map((image) => image.path);
-		return {
-			...base,
-			references: references.length > 0 ? references : void 0,
-			referenceInfluences: references.length > 0 ? references.map(() => 1) : void 0,
-			strength: references.length > 0 ? 1 : void 0,
-			width: defaultImageSize,
-			height: defaultImageSize
-		};
-	}
-	if (input.mode === "subject") {
-		if (!input.subject) throw new Error("Subject mode requires a subject image");
-		const refs = input.refs ?? [];
-		const references = [input.subject, ...refs].map((image) => image.path);
-		const size = imageSizeForAspectRatio(input.subject.size);
-		return {
-			...base,
-			references,
-			referenceInfluences: references.map(() => 1),
-			strength: 1,
-			width: size.width,
-			height: size.height
-		};
-	}
-	if (input.mode === "edit") {
-		if (!input.source) throw new Error("Edit requires a source image");
-		const references = (input.refs ?? []).map((image) => image.path);
-		const size = roundedImageSize(input.source.size);
+async function createFluxTokenizer(path, manifest) {
+	const paths = fluxImageModelPaths(path, manifest);
+	const tokenizer = new Tokenizer_default(await require_files.files.file(paths.textEncoderPath, "tokenizer.json").json(), await require_files.files.file(paths.textEncoderPath, "tokenizer_config.json").json());
+	const padTokenId = 151643;
+	return ({ prompt, maxLength }) => {
+		const inputIds = tokenArray(tokenizer.encode(formatQwen3KleinPrompt(prompt)).ids, "inputIds").slice(0, maxLength);
+		const attentionMask = inputIds.map(() => 1);
+		while (inputIds.length < maxLength) {
+			inputIds.push(padTokenId);
+			attentionMask.push(0);
+		}
 		return {
-			...base,
-			image: input.source.path,
-			references: references.length > 0 ? references : void 0,
-			referenceInfluences: references.length > 0 ? references.map(() => 1) : void 0,
-			strength: references.length > 0 ? 1 : .35,
-			width: size.width,
-			height: size.height
+			inputIds,
+			attentionMask
 		};
-	}
-	if (!input.source) throw new Error("Outpaint requires a source image");
-	if (!input.rect) throw new Error("Outpaint requires a source placement");
-	return {
-		...base,
-		image: input.source.path,
-		outpaint: {
-			width: defaultImageSize,
-			height: defaultImageSize,
-			sourceRect: input.rect,
-			autoCrop: true
-		},
-		strength: .8,
-		width: defaultImageSize,
-		height: defaultImageSize
 	};
 }
-function useImageComposer(modeOrOptions, options = {}) {
-	if (typeof modeOrOptions !== "string") return useImageComposerController(modeOrOptions ?? {});
-	const mode = modeOrOptions;
-	if (mode === "text") return useTextComposer(options);
-	if (mode === "subject") return useSubjectComposer(options);
-	if (mode === "edit") return useEditComposer(options);
-	return useOutpaintComposer(options);
-}
-function useImageComposerController(options) {
-	const [mode, setMode] = require_state.useAtom(useComposerAtom(options.initialMode ?? "text"));
-	const text = useTextComposer(options);
-	const subject = useSubjectComposer(options);
-	const edit = useEditComposer(options);
-	const outpaint = useOutpaintComposer(options);
-	const active = mode === "text" ? text : mode === "subject" ? subject : mode === "edit" ? edit : outpaint;
-	const error = active.error ?? text.error ?? subject.error ?? edit.error ?? outpaint.error;
+function formatQwen3KleinPrompt(prompt) {
+	return [
+		"<|im_start|>user",
+		`${prompt.replaceAll("[IMG]", "")}<|im_end|>`,
+		"<|im_start|>assistant",
+		"<think>",
+		"",
+		"</think>",
+		""
+	].join("\n");
+}
+function assertPositiveInteger(value, name) {
+	if (!Number.isInteger(value) || value <= 0) throw new AIError("invalid_model", `${name} must be a positive integer`);
+}
+function assertUnitInterval(value, name) {
+	if (!Number.isFinite(value) || value <= 0 || value > 1) throw new AIError("invalid_model", `${name} must be greater than 0 and at most 1`);
+}
+function filePathFromUri(value, name) {
+	const path = value.trim();
+	if (!path) throw new AIError("invalid_message", `${name} must not be empty`);
+	if (!path.startsWith("file://")) return path;
+	try {
+		return decodeURIComponent(new URL(path).pathname);
+	} catch (error) {
+		throw new AIError("invalid_message", `Invalid ${name} file URI`, error);
+	}
+}
+function assertTokenArray(value, name) {
+	if (value.length === 0) throw new AIError("invalid_message", `${name} must not be empty`);
+	for (const token of value) if (!Number.isInteger(token) || token < 0) throw new AIError("invalid_message", `${name} must contain token ids`);
+}
+function imageResult(value, model, fallbackMetadata) {
+	if (!isRecord(value) || typeof value.uri !== "string" || typeof value.width !== "number" || typeof value.height !== "number" || value.model !== model) throw new AIError("image_generation_failed", "Expected generated image URI");
+	const result = value;
+	const metadata = isRecord(result.metadata) ? result.metadata : {};
 	return {
-		mode,
-		setMode,
-		active,
-		text,
-		subject,
-		edit,
-		outpaint,
-		isPicking: text.isPicking || subject.isPicking || edit.isPicking || outpaint.isPicking,
-		error,
-		request: (prompt) => active.request(prompt),
-		clear() {
-			text.clear();
-			subject.clear();
-			edit.clear();
-			outpaint.clear();
+		uri: value.uri,
+		width: value.width,
+		height: value.height,
+		model,
+		metadata: {
+			...fallbackMetadata,
+			model: metadata.model === model ? model : fallbackMetadata.model,
+			width: typeof metadata.width === "number" ? metadata.width : value.width,
+			height: typeof metadata.height === "number" ? metadata.height : value.height,
+			steps: typeof metadata.steps === "number" ? metadata.steps : fallbackMetadata.steps,
+			guidance: typeof metadata.guidance === "number" ? metadata.guidance : fallbackMetadata.guidance,
+			strength: typeof metadata.strength === "number" ? metadata.strength : fallbackMetadata.strength,
+			seed: typeof metadata.seed === "number" ? metadata.seed : fallbackMetadata.seed,
+			elapsedMs: typeof metadata.elapsedMs === "number" ? metadata.elapsedMs : fallbackMetadata.elapsedMs,
+			appliedLoRAs: Array.isArray(metadata.appliedLoRAs) ? metadata.appliedLoRAs.flatMap((item) => {
+				if (!isRecord(item) || typeof item.path !== "string") return [];
+				return [{
+					id: typeof item.id === "string" ? item.id : void 0,
+					path: item.path,
+					scale: typeof item.scale === "number" ? item.scale : 1
+				}];
+			}) : fallbackMetadata.appliedLoRAs
 		}
 	};
 }
-function useTextComposer(options) {
-	const store = useComposerAtom({
-		refs: [],
-		isPicking: false,
-		error: null
-	});
-	const [state, setState] = require_state.useAtom(store);
-	const maxRefs = options.maxRefs ?? 3;
-	async function pickRefs() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const refs = [...store.get().refs, ...await pickImages(options.inputRoot)].slice(0, maxRefs);
-			setState((current) => ({
-				...current,
-				refs,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
+async function withImageStage(stage, operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		if (error instanceof ImageGenerationError) throw error;
+		if (error instanceof AIError && error.code === "generation_canceled") throw error;
+		throw new ImageGenerationError(stage, error instanceof Error ? error.message : String(error), error);
 	}
-	return {
-		mode: "text",
-		...state,
-		pickRefs,
-		removeRef: (index) => setState((current) => removeRefFromState(current, index)),
-		request: (prompt) => ({
-			mode: "text",
-			prompt,
-			refs: store.get().refs
-		}),
-		clear: () => setState({
-			refs: [],
-			isPicking: false,
-			error: null
-		})
-	};
 }
-function useSubjectComposer(options) {
-	const store = useComposerAtom({
-		subject: null,
-		refs: [],
-		isPicking: false,
-		error: null
-	});
-	const [state, setState] = require_state.useAtom(store);
-	const maxRefs = options.maxRefs ?? 2;
-	async function pickSubject() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const subject = await pickOneImage(options.inputRoot);
-			setState((current) => ({
-				...current,
-				subject: subject ?? current.subject,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	async function pickRefs() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const refs = [...store.get().refs, ...await pickImages(options.inputRoot)].slice(0, maxRefs);
-			setState((current) => ({
-				...current,
-				refs,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
+function imagegenProgress(value) {
+	const currentStep = value.currentStep;
+	const totalSteps = value.totalSteps;
+	if (typeof currentStep !== "number" || !Number.isFinite(currentStep) || typeof totalSteps !== "number" || !Number.isFinite(totalSteps) || totalSteps <= 0) return;
 	return {
-		mode: "subject",
-		...state,
-		pickSubject,
-		removeSubject: () => setState((current) => ({
-			...current,
-			subject: null
-		})),
-		pickRefs,
-		removeRef: (index) => setState((current) => removeRefFromState(current, index)),
-		request: (prompt) => {
-			const current = store.get();
-			return {
-				mode: "subject",
-				prompt,
-				subject: current.subject,
-				refs: current.refs
-			};
-		},
-		clear: () => setState({
-			subject: null,
-			refs: [],
-			isPicking: false,
-			error: null
-		})
+		currentStep,
+		totalSteps,
+		fraction: Math.max(0, Math.min(1, currentStep / totalSteps))
 	};
 }
-function useEditComposer(options) {
-	const store = useComposerAtom({
-		source: null,
-		refs: [],
-		isPicking: false,
-		error: null
-	});
-	const [state, setState] = require_state.useAtom(store);
-	const maxRefs = options.maxRefs ?? 3;
-	async function pickSource() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const source = await pickOneImage(options.inputRoot);
-			setState((current) => ({
-				...current,
-				source: source ?? current.source,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	async function pickRefs() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const refs = [...store.get().refs, ...await pickImages(options.inputRoot)].slice(0, maxRefs);
-			setState((current) => ({
-				...current,
-				refs,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new AIError("generation_canceled", "Image generation canceled");
+}
+function nativeErrorStage(error) {
+	const stage = (error instanceof Error ? error.message : String(error)).match(/^\[(download|tokenize|encode|denoise|decode|write)]\s/)?.[1] ?? (isRecord(error) && typeof error.stage === "string" ? error.stage : isRecord(error) && isRecord(error.userInfo) && typeof error.userInfo.stage === "string" ? error.userInfo.stage : void 0);
+	return stage === "download" || stage === "tokenize" || stage === "encode" || stage === "denoise" || stage === "decode" || stage === "write" ? stage : void 0;
+}
+function nativeErrorMessage(error) {
+	return (error instanceof Error ? error.message : String(error)).replace(/^\[(download|tokenize|encode|denoise|decode|write)]\s*/, "");
+}
+async function prepareImageModel(options = {}) {
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	return prepareImageModelAtPath(definition, options, options.directory ? require_files.files.directory(options.directory, definition.manifest.directory).path : modelCacheRoot(definition.manifest).path);
+}
+async function prepareImageModelAtPath(definition, options, path) {
+	const model = definition.manifest.model;
+	const root = require_files.files.directory(path);
+	await root.create({ recursive: true });
+	const headers = options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0;
+	const total = definition.files.length;
+	const bytesByFile = /* @__PURE__ */ new Map();
+	const emitProgress = (progress) => {
+		const file = definition.files.find((candidate) => candidate.destination === progress.file);
+		const bytesWritten = file ? Math.min(progress.bytesWritten, file.bytes) : progress.bytesWritten;
+		bytesByFile.set(progress.file, bytesWritten);
+		const modelBytesWritten = Array.from(bytesByFile.values()).reduce((sum, bytes) => sum + bytes, 0);
+		options.onProgress?.({
+			...progress,
+			bytesWritten,
+			modelBytesWritten,
+			totalModelBytes: definition.totalBytes,
+			modelFraction: modelBytesWritten / definition.totalBytes
+		});
+	};
+	const missingFiles = [];
+	for (const [index, file] of definition.files.entries()) {
+		const stat = await require_files.files.file(root.path, file.destination).stat();
+		if (stat.type === "file" && stat.size === file.bytes) emitProgress({
+			model,
+			file: file.destination,
+			index: index + 1,
+			total,
+			bytesWritten: file.bytes,
+			totalBytes: file.bytes,
+			fraction: 1
+		});
+		else missingFiles.push({
+			file,
+			index: index + 1
+		});
 	}
+	await runConcurrent(missingFiles, downloadConcurrency(options.concurrency), async ({ file, index }) => {
+		await ensureModelFile({
+			model,
+			path: root.path,
+			file,
+			headers,
+			index,
+			total,
+			onProgress: emitProgress
+		});
+	});
+	await writePreparedManifest(root.path, definition.manifest);
 	return {
-		mode: "edit",
-		...state,
-		pickSource,
-		removeSource: () => setState((current) => ({
-			...current,
-			source: null
-		})),
-		pickRefs,
-		removeRef: (index) => setState((current) => removeRefFromState(current, index)),
-		request: (prompt) => {
-			const current = store.get();
-			return {
-				mode: "edit",
-				prompt,
-				source: current.source,
-				refs: current.refs
-			};
-		},
-		clear: () => setState({
-			source: null,
-			refs: [],
-			isPicking: false,
-			error: null
-		})
+		model,
+		...fluxImageModelPaths(root.path, definition.manifest),
+		tokenizer: await createFluxTokenizer(root.path, definition.manifest)
 	};
 }
-function useOutpaintComposer(options) {
-	const store = useComposerAtom({
-		source: null,
-		rect: null,
-		isPicking: false,
-		error: null
+async function verifyImageModel(options = {}) {
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	return imageModelState(definition.manifest.model, modelPathFromOptions(definition, options.path));
+}
+async function listImageModels(options = {}) {
+	return [...await Promise.all([flux2Klein4B8BitAbliterated.model, ternaryBonsaiImage4B.model].map((model) => {
+		const definition = imageModelDefinition(model);
+		return imageModelState(model, options.directory ? require_files.files.directory(options.directory, definition.manifest.directory).path : modelPathFromOptions(definition, void 0));
+	}))];
+}
+async function deleteImageModel(options = {}) {
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	await require_files.files.directory(modelPathFromOptions(definition, options.path)).delete({ recursive: true });
+}
+async function imageMemoryTelemetry() {
+	const value = await bridge().imageMemoryTelemetry?.();
+	if (!value) throw new AIError("image_generation_failed", "Image service is unavailable");
+	return value;
+}
+async function unloadImageModel() {
+	return await bridge().unloadImageModel?.() ?? false;
+}
+async function upscaleImage(options) {
+	throwIfAborted(options.signal);
+	const scale = normalizeUpscaleScale(options.scale);
+	const value = await bridge().upscaleImage?.({
+		imagePath: filePathFromUri(options.image, "image"),
+		scale
 	});
-	const [state, setState] = require_state.useAtom(store);
-	async function pickSource() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const source = await pickOneImage(options.inputRoot);
-			setState((current) => ({
-				...current,
-				source: source ?? current.source,
-				rect: source ? initialOutpaintRect(source.size) : current.rect,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	return {
-		mode: "outpaint",
-		...state,
-		pickSource,
-		removeSource: () => setState((current) => ({
-			...current,
-			source: null,
-			rect: null
-		})),
-		setRect: (rect) => setState((current) => ({
-			...current,
-			rect
-		})),
-		request: (prompt) => {
-			const current = store.get();
-			return {
-				mode: "outpaint",
-				prompt,
-				source: current.source,
-				rect: current.rect
-			};
-		},
-		clear: () => setState({
-			source: null,
-			rect: null,
-			isPicking: false,
-			error: null
-		})
-	};
+	throwIfAborted(options.signal);
+	if (!value || typeof value.uri !== "string" || !Number.isInteger(value.width) || !Number.isInteger(value.height) || value.scale !== scale) throw new AIError("image_generation_failed", "Native image upscaling returned an invalid result");
+	return value;
 }
-function useImageGeneration() {
-	const [state, setState] = require_state.useAtom(useComposerAtom({
-		imageUri: null,
-		result: null,
-		progress: 0,
-		status: "",
-		isGenerating: false,
-		error: null
-	}));
-	const abortControllerRef = useStableRef(null);
-	async function run(input, options = {}) {
-		if (abortControllerRef.current) return null;
-		const abortController = new AbortController();
-		abortControllerRef.current = abortController;
-		setState((current) => ({
-			...current,
-			imageUri: null,
-			result: null,
-			progress: 0,
-			status: "Generating...",
-			isGenerating: true,
-			error: null
-		}));
-		try {
-			const result = await generateImage(buildImageGenerationRequest(input, {
-				...options,
-				signal: abortController.signal,
-				onModelProgress(progress) {
-					setState((current) => ({
-						...current,
-						progress: progress.modelFraction >= 1 ? .15 : progress.modelFraction * .15,
-						status: progress.modelFraction >= 1 ? "Generating..." : modelProgressStatus(progress)
-					}));
-				},
-				onProgress(progress) {
-					setState((current) => ({
-						...current,
-						progress: .15 + progress.currentStep / progress.totalSteps * .85,
-						status: `Step ${progress.currentStep}/${progress.totalSteps}`
-					}));
-				}
-			}));
-			setState((current) => ({
-				...current,
-				imageUri: result.uri,
-				result,
-				progress: 1,
-				status: `${result.metadata.width}×${result.metadata.height} • ${result.metadata.steps} steps`,
-				isGenerating: false
-			}));
-			return result;
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				status: error instanceof Error ? error.message : String(error),
-				error: errorFromUnknown(error),
-				isGenerating: false
-			}));
-			return null;
-		} finally {
-			if (abortControllerRef.current === abortController) abortControllerRef.current = null;
-		}
-	}
-	function cancel() {
-		setState((current) => ({
-			...current,
-			status: "Canceling..."
-		}));
-		abortControllerRef.current?.abort();
-	}
-	function clear() {
-		setState({
-			imageUri: null,
-			result: null,
-			progress: 0,
-			status: "",
-			isGenerating: false,
-			error: null
-		});
+async function prepareImageLoRA(lora, options = {}) {
+	assertLoRADefinition(lora);
+	const resolvedDefinition = await resolveHuggingFaceLoRA(lora, options);
+	const id = safeCacheName(lora.id, "lora.id");
+	const scale = assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
+	if (resolvedDefinition.source.type === "local") {
+		const path = filePathFromUri(resolvedDefinition.source.path, `lora ${id}`);
+		const stat$1 = await require_files.files.file(path).stat();
+		if (stat$1.type !== "file") throw new AIError("invalid_model", `Missing LoRA file: ${path}`);
+		if (!hasSafetensorsHeader(stat$1.size)) throw new AIError("invalid_model", `Invalid LoRA safetensors file: ${path}`);
+		return {
+			id: lora.id,
+			description: lora.description,
+			path,
+			uri: stat$1.uri,
+			scale,
+			source: resolvedDefinition.source,
+			metadata: lora.metadata
+		};
 	}
+	const url = loraUrl(resolvedDefinition);
+	if (!url) throw new AIError("invalid_model", `Unsupported LoRA source: ${lora.id}`);
+	const root = imageLoRARoot().directory(id);
+	await root.create({ recursive: true });
+	const destination = root.file(safeCacheName(sourceFileName(resolvedDefinition), "lora filename"));
+	const expectedBytes = loraExpectedBytes(resolvedDefinition);
+	const stat = await destination.stat();
+	if (stat.type !== "file" || !hasSafetensorsHeader(stat.size) || expectedBytes !== void 0 && stat.size !== expectedBytes) await destination.download(url, {
+		headers: loraHeaders(resolvedDefinition, options.accessToken),
+		expectedBytes,
+		atomic: true,
+		resume: true,
+		signal: options.signal,
+		onProgress(progress) {
+			options.onProgress?.({
+				lora: lora.id,
+				file: destination.path,
+				bytesWritten: progress.bytesWritten,
+				totalBytes: progress.totalBytes,
+				fraction: progress.fraction
+			});
+		}
+	}).result;
+	await root.file("manifest.json").write(JSON.stringify({
+		formatVersion: 1,
+		id: lora.id,
+		file: destination.path.split("/").pop(),
+		source: resolvedDefinition.source,
+		metadata: lora.metadata
+	}, null, 2));
+	const preparedStat = await destination.stat();
+	if (preparedStat.type !== "file" || !hasSafetensorsHeader(preparedStat.size)) throw new AIError("invalid_model", `Invalid LoRA safetensors file: ${destination.path}`);
 	return {
-		...state,
-		run,
-		cancel,
-		clear
+		id: lora.id,
+		description: lora.description,
+		path: destination.path,
+		uri: preparedStat.uri,
+		scale,
+		source: resolvedDefinition.source,
+		metadata: lora.metadata
 	};
 }
-function useImageModel() {
-	const [state, setState] = require_state.useAtom(useComposerAtom({
-		checking: false,
-		state: null,
-		error: null
-	}));
-	async function check() {
-		setState((current) => ({
-			...current,
-			checking: true,
-			error: null
-		}));
-		try {
-			const [modelState] = await listImageModels();
-			setState({
-				checking: false,
-				state: modelState ?? null,
-				error: null
-			});
-			return modelState ?? null;
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				checking: false,
-				error: errorFromUnknown(error)
-			}));
-			return null;
+async function verifyImageLoRA(lora) {
+	assertLoRADefinition(lora);
+	const scale = assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
+	let resolvedDefinition = lora;
+	if (lora.source.type === "huggingface" && !lora.source.path) {
+		const manifestFile = imageLoRARoot().directory(safeCacheName(lora.id, "lora.id")).file("manifest.json");
+		if ((await manifestFile.stat()).type === "file") {
+			const manifest = await manifestFile.json();
+			if (isRecord(manifest) && isRecord(manifest.source) && manifest.source.type === "huggingface" && manifest.source.repo === lora.source.repo && (manifest.source.revision ?? "main") === (lora.source.revision ?? "main") && typeof manifest.source.path === "string") resolvedDefinition = {
+				...lora,
+				source: {
+					...lora.source,
+					path: manifest.source.path,
+					revision: typeof manifest.source.revision === "string" ? manifest.source.revision : lora.source.revision,
+					bytes: typeof manifest.source.bytes === "number" ? manifest.source.bytes : lora.source.bytes
+				}
+			};
 		}
 	}
+	const file = resolvedDefinition.source.type === "local" ? require_files.files.file(filePathFromUri(resolvedDefinition.source.path, `lora ${lora.id}`)) : cachedLoRAFile(resolvedDefinition);
+	const stat = await file.stat();
+	const expectedBytes = loraExpectedBytes(resolvedDefinition);
+	const installed = stat.type === "file";
+	const verified = installed && hasSafetensorsHeader(stat.size) && (expectedBytes === void 0 || stat.size === expectedBytes);
 	return {
-		...state,
-		installed: state.state?.installed ?? false,
-		verified: state.state?.verified ?? false,
-		missingFiles: state.state?.missingFiles ?? [],
-		bytesPresent: state.state?.bytesPresent ?? 0,
-		totalBytes: state.state?.totalBytes ?? 0,
-		check
-	};
-}
-function useComposerAtom(initialValue) {
-	const ref = useStableRef(null);
-	ref.current ??= require_state.atom(initialValue);
-	return ref.current;
-}
-function useStableRef(initialValue) {
-	return (0, react.useRef)(initialValue);
-}
-function removeRefFromState(state, index) {
-	return {
-		...state,
-		refs: state.refs.filter((_, i) => i !== index)
+		id: lora.id,
+		description: lora.description,
+		path: file.path,
+		uri: stat.uri,
+		scale,
+		source: resolvedDefinition.source,
+		metadata: lora.metadata,
+		installed,
+		verified,
+		size: stat.size
 	};
 }
-function inputDestination(inputRoot) {
-	return require_files.files.directory(inputRoot ?? require_files.files.paths.shared, "ImageGenerationInputs", String(Date.now()));
-}
-async function pickOneImage(inputRoot) {
-	const [picked] = await require_files.files.pick({
-		type: "image",
-		destination: inputDestination(inputRoot)
-	});
-	if (!picked) return null;
-	return Object.assign(picked, { size: await getImageSize(picked.uri) });
-}
-async function pickImages(inputRoot) {
-	const picked = await require_files.files.pick({
-		type: "image",
-		multiple: true,
-		destination: inputDestination(inputRoot)
-	});
-	return Promise.all(picked.map(async (image) => Object.assign(image, { size: await getImageSize(image.uri) })));
-}
-function getImageSize(uri) {
-	return new Promise((resolve, reject) => {
-		react_native.Image.getSize(uri, (width, height) => resolve({
-			width,
-			height
-		}), reject);
-	});
-}
-function errorFromUnknown(error) {
-	return error instanceof Error ? error : new Error(String(error));
+async function listImageLoRAs(loras) {
+	return Promise.all(loras.map((lora) => verifyImageLoRA(lora)));
 }
-function modelProgressStatus(progress) {
-	return `Model ${Math.round(progress.modelFraction * 100)}% • ${formatBytes(progress.modelBytesWritten)} / ${formatBytes(progress.totalModelBytes)}`;
+async function deleteImageLoRA(lora) {
+	const id = safeCacheName(typeof lora === "string" ? lora : lora.id, "lora.id");
+	await imageLoRARoot().directory(id).delete({ recursive: true });
 }
-function formatBytes(value) {
-	if (value < 1024) return `${value} B`;
-	const units = [
-		"KB",
-		"MB",
-		"GB",
-		"TB"
-	];
-	let size = value / 1024;
-	let index = 0;
-	while (size >= 1024 && index < units.length - 1) {
-		size /= 1024;
-		index += 1;
+async function prepareSelectedImageLoRAs(loras, model, options = {}) {
+	const prepared = [];
+	for (const lora of loras) {
+		assertLoRADefinition(lora);
+		assertLoRACompatibility(lora, model);
+		prepared.push(await prepareImageLoRA(lora, options));
 	}
-	return `${size.toFixed(size >= 10 ? 1 : 2)} ${units[index]}`;
+	return prepared;
 }
-
-//#endregion
-//#region src/ai/shape.ts
-var ShapeError = class extends Error {
-	constructor(code, message, issues = []) {
-		super(message);
-		this.code = code;
-		this.issues = issues;
-		this.name = "ShapeError";
+async function generateImage(options) {
+	throwIfAborted(options.signal);
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	const model = definition.manifest.model;
+	const prompt = options.prompt.trim();
+	if (!prompt) throw new AIError("invalid_message", "Expected prompt");
+	const presetSize = options.aspectRatio ? imageSizeForPreset(options.aspectRatio) : void 0;
+	const requestedSize = normalizeImageSize({
+		width: options.width ?? presetSize?.width ?? 1024,
+		height: options.height ?? presetSize?.height ?? 1024
+	}, false);
+	const width = requestedSize.width;
+	const height = requestedSize.height;
+	const outpaintSize = options.outpaint ? normalizeImageSize({
+		width: options.outpaint.width,
+		height: options.outpaint.height
+	}, false) : void 0;
+	if (options.outpaint && (outpaintSize?.width !== options.outpaint.width || outpaintSize?.height !== options.outpaint.height)) throw new AIError("invalid_model", "outpaint width and height must be multiples of 16");
+	const steps = options.steps ?? 4;
+	const guidance = options.guidance ?? 1;
+	const seed = options.seed ?? Math.floor(Math.random() * 4294967296);
+	const sourceImagePath = options.image ? filePathFromUri(options.image, "image") : void 0;
+	const maskImagePath = options.mask ? filePathFromUri(options.mask, "mask") : void 0;
+	const referenceImagePaths = (options.references ?? []).map((reference, index) => filePathFromUri(reference, `references[${index}]`));
+	const isImageConditioned = Boolean(sourceImagePath) || referenceImagePaths.length > 0;
+	const strength = options.strength ?? (isImageConditioned ? .8 : void 0);
+	if (maskImagePath && !sourceImagePath) throw new AIError("invalid_message", "mask requires image");
+	if (options.maskMode !== void 0 && options.maskMode !== "paint" && options.maskMode !== "preserve") throw new AIError("invalid_model", "maskMode must be paint or preserve");
+	if (options.outpaint && !sourceImagePath) throw new AIError("invalid_message", "outpaint requires image");
+	if (options.outpaint) {
+		assertPositiveInteger(options.outpaint.width, "outpaint.width");
+		assertPositiveInteger(options.outpaint.height, "outpaint.height");
+		const rect = options.outpaint.sourceRect;
+		if (!rect) throw new AIError("invalid_model", "outpaint.sourceRect is required");
+		assertPositiveInteger(rect.width, "outpaint.sourceRect.width");
+		assertPositiveInteger(rect.height, "outpaint.sourceRect.height");
+		if (!Number.isInteger(rect.x) || !Number.isInteger(rect.y)) throw new AIError("invalid_model", "outpaint.sourceRect x and y must be integers");
+		const canvasWidth = outpaintSize?.width ?? options.outpaint.width;
+		const canvasHeight = outpaintSize?.height ?? options.outpaint.height;
+		if (!(rect.x < canvasWidth && rect.y < canvasHeight && rect.x + rect.width > 0 && rect.y + rect.height > 0)) throw new AIError("invalid_model", "outpaint.sourceRect must intersect the canvas");
+		if (!options.outpaint.autoCrop && (rect.x < 0 || rect.y < 0 || rect.x + rect.width > canvasWidth || rect.y + rect.height > canvasHeight)) throw new AIError("invalid_model", "outpaint.sourceRect must fit within the outpaint canvas");
 	}
-};
-function issue(message, path = []) {
-	return {
-		message,
-		path
-	};
-}
-function validateDefinition(definition, value, path = []) {
-	if (definition === "string" || definition === "number" || definition === "boolean") {
-		if (typeof value === definition) return { value };
-		return { issues: [issue(`Expected ${path.join(".") || "value"} to be ${definition}`, path)] };
-	}
-	if (Array.isArray(definition)) {
-		if (!Array.isArray(value)) return { issues: [issue(`Expected ${path.join(".") || "value"} to be array`, path)] };
-		const itemDefinition = definition[0];
-		const issues$1 = [];
-		const output$1 = [];
-		for (const [index, item] of value.entries()) {
-			const result = validateDefinition(itemDefinition, item, [...path, index]);
-			if (result.issues !== void 0) issues$1.push(...result.issues);
-			else output$1.push(result.value);
-		}
-		if (issues$1.length > 0) return { issues: issues$1 };
-		return { value: output$1 };
-	}
-	if (!isRecord(value)) return { issues: [issue(`Expected ${path.join(".") || "value"} to be object`, path)] };
-	const output = {};
-	const issues = [];
-	for (const [key, field] of Object.entries(definition)) {
-		const result = validateDefinition(field, value[key], [...path, key]);
-		if (result.issues !== void 0) issues.push(...result.issues);
-		else output[key] = result.value;
-	}
-	if (issues.length > 0) return { issues };
-	return { value: output };
-}
-function bridgeSchema(definition) {
-	if (definition === "string" || definition === "number" || definition === "boolean") return { type: definition };
-	if (Array.isArray(definition)) return {
-		type: "array",
-		items: bridgeSchema(definition[0])
-	};
-	const properties = {};
-	const required = [];
-	for (const [key, value] of Object.entries(definition)) {
-		properties[key] = bridgeSchema(value);
-		required.push(key);
+	if (options.resizeMode !== void 0 && options.resizeMode !== "stretch" && options.resizeMode !== "fit" && options.resizeMode !== "crop") throw new AIError("invalid_model", "resizeMode must be stretch, fit, or crop");
+	if (options.maxInputLongSide !== void 0 && options.maxInputLongSide !== false && (!Number.isInteger(options.maxInputLongSide) || options.maxInputLongSide < 64)) throw new AIError("invalid_model", "maxInputLongSide must be false or an integer of at least 64");
+	assertPositiveInteger(width, "width");
+	assertPositiveInteger(height, "height");
+	assertPositiveInteger(steps, "steps");
+	if (seed !== void 0 && (!Number.isInteger(seed) || seed < 0)) throw new AIError("invalid_model", "seed must be a non-negative integer");
+	if (!Number.isFinite(guidance) || guidance <= 0) throw new AIError("invalid_model", "guidance must be a positive number");
+	if (referenceImagePaths.length > 3) throw new AIError("invalid_model", "references must contain at most 3 images");
+	if (options.referenceInfluences !== void 0) {
+		if (options.referenceInfluences.length !== referenceImagePaths.length) throw new AIError("invalid_model", "referenceInfluences must match references length");
+		for (const [index, influence] of options.referenceInfluences.entries()) if (!Number.isFinite(influence) || influence < 0) throw new AIError("invalid_model", `referenceInfluences[${index}] must be a non-negative number`);
 	}
-	return {
-		type: "object",
-		properties,
-		required
+	if (strength !== void 0) assertUnitInterval(strength, "strength");
+	const selectedLoRAs = options.loras?.length ? await withImageStage("download", () => prepareSelectedImageLoRAs(options.loras ?? [], model, {
+		accessToken: options.accessToken,
+		signal: options.signal
+	})) : [];
+	const sigmaSchedule = imageSigmaSchedule(selectedLoRAs.map((lora) => lora.metadata?.sigmaSchedule));
+	if (sigmaSchedule && options.steps !== void 0 && options.steps !== sigmaSchedule.length) throw new AIError("invalid_model", `steps must equal the LoRA sigma schedule length (${sigmaSchedule.length})`);
+	const generationSteps = sigmaSchedule?.length ?? steps;
+	const prepared = options.path && options.tokenizer ? void 0 : await withImageStage("download", () => prepareImageModelAtPath(definition, {
+		model,
+		accessToken: options.accessToken,
+		concurrency: options.concurrency,
+		onProgress: options.onModelProgress
+	}, options.path ?? modelCacheRoot(definition.manifest).path));
+	throwIfAborted(options.signal);
+	const tokenizer = options.tokenizer ?? prepared?.tokenizer;
+	const modelPath = options.path ?? prepared?.path;
+	if (!tokenizer || !modelPath) throw new AIError("invalid_model", "Expected image model path and tokenizer");
+	const tokenized = await withImageStage("tokenize", () => tokenizer({
+		prompt,
+		maxLength: 512
+	}));
+	throwIfAborted(options.signal);
+	await withImageStage("tokenize", () => {
+		assertTokenArray(tokenized.inputIds, "inputIds");
+		assertTokenArray(tokenized.attentionMask, "attentionMask");
+		if (tokenized.inputIds.length !== tokenized.attentionMask.length) throw new AIError("invalid_message", "inputIds and attentionMask must have the same length");
+	});
+	const paths = fluxImageModelPaths(modelPath, definition.manifest);
+	const request = {
+		model,
+		prompt,
+		sourceImagePath,
+		maskImagePath,
+		maskMode: options.maskMode,
+		outpaintWidth: outpaintSize?.width,
+		outpaintHeight: outpaintSize?.height,
+		outpaintSourceX: options.outpaint?.sourceRect.x,
+		outpaintSourceY: options.outpaint?.sourceRect.y,
+		outpaintSourceWidth: options.outpaint?.sourceRect.width,
+		outpaintSourceHeight: options.outpaint?.sourceRect.height,
+		outpaintAutoCrop: options.outpaint?.autoCrop,
+		resizeMode: options.resizeMode,
+		maxInputLongSide: options.maxInputLongSide === false ? 0 : options.maxInputLongSide ?? defaultImageLongSide,
+		referenceImagePaths,
+		referenceInfluences: options.referenceInfluences,
+		loraPaths: selectedLoRAs.map((lora) => lora.path),
+		loraScales: selectedLoRAs.map((lora) => lora.scale),
+		loraIds: selectedLoRAs.map((lora) => lora.id),
+		sigmaSchedule,
+		width,
+		height,
+		steps: generationSteps,
+		guidance,
+		strength,
+		seed,
+		inputIds: tokenized.inputIds,
+		attentionMask: tokenized.attentionMask,
+		modelRoot: paths.path,
+		textEncoderPath: paths.textEncoderPath,
+		transformerPath: paths.transformerPath,
+		vaePath: paths.vaePath
 	};
-}
-function assertValidShape(definition, path = "shape") {
-	if (definition === "string" || definition === "number" || definition === "boolean") return;
-	if (Array.isArray(definition)) {
-		if (definition.length !== 1) throw new ShapeError("invalid_shape", `${path} arrays must contain exactly one item shape`);
-		assertValidShape(definition[0], `${path}[0]`);
-		return;
-	}
-	if (!isRecord(definition)) throw new ShapeError("invalid_shape", `${path} must be a shape object`);
-	for (const [key, value] of Object.entries(definition)) assertValidShape(value, `${path}.${key}`);
-}
-function createShape(definition) {
-	assertValidShape(definition);
-	const api = {
-		"~standard": {
-			version: 1,
-			vendor: "bleam",
-			validate(value) {
-				return api.safeParse(value);
-			}
-		},
-		parse(value) {
-			const result = api.safeParse(value);
-			if (result.issues !== void 0) throw new ShapeError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
-			return result.value;
-		},
-		safeParse(value) {
-			return validateDefinition(definition, value);
-		},
-		toJSONSchema() {
-			return bridgeSchema(definition);
-		}
+	const fallbackMetadata = {
+		model,
+		width: outpaintSize?.width ?? width,
+		height: outpaintSize?.height ?? height,
+		steps: generationSteps,
+		guidance,
+		strength,
+		seed,
+		appliedLoRAs: selectedLoRAs.map((lora) => ({
+			id: lora.id,
+			path: lora.path,
+			scale: lora.scale
+		})),
+		sigmaSchedule
 	};
-	return api;
-}
-function shape(definition) {
-	return createShape(definition);
-}
-function schemaToBridgeSchema(schema) {
-	const schemaWithBridge = schema;
-	if (typeof schemaWithBridge.toJSONSchema === "function") return schemaWithBridge.toJSONSchema();
-	throw new AIError("invalid_schema", "Structured output schemas must implement toJSONSchema()");
-}
-function validateStructuredInput(input) {
-	const result = input.shape["~standard"].validate(input.value);
-	if (result.issues !== void 0) throw new AIError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
-	return result.value;
-}
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	if (isRecord(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
-	return JSON.stringify(value) ?? "undefined";
-}
-
-//#endregion
-//#region src/ai/bonsai-generation.ts
-async function prepareBonsaiGeneration(input) {
-	const state = await verifyBonsaiTextModel(input.model, { path: input.path });
-	if (!state.verified) throw new AIError("model_unavailable", `${input.model.id} is not prepared. Call prepareTextModel() before generation.`);
-	const tokenizer = new Tokenizer_default(await require_files.files.file(state.path, "tokenizer.json").json(), await require_files.files.file(state.path, "tokenizer_config.json").json());
-	const inputIds = tokenizer.encode(formatMessages(messagesFromInput(input))).ids.map(Number);
-	if (!inputIds.length || inputIds.some((token) => !Number.isInteger(token))) throw new AIError("invalid_message", "Tokenizer returned invalid token ids");
-	return {
-		request: {
-			id: input.id,
-			model: input.model.id,
-			modelPath: state.path,
-			inputIds,
-			endTokenIds: endTokenIds(input.model.id),
-			maxTokens: input.maxTokens,
-			temperature: input.temperature,
-			seed: input.seed
-		},
-		decode(tokenIds) {
-			return tokenIds.length ? tokenizer.decode(tokenIds, { skip_special_tokens: true }) : "";
+	try {
+		const native = bridge();
+		const cancelNative = () => {
+			native.cancelImagegen?.();
+		};
+		const subscription = options.onProgress ? native.addListener?.("imagegenProgress", (event) => {
+			const progress = imagegenProgress(event);
+			if (progress) options.onProgress?.(progress);
+		}) : void 0;
+		try {
+			options.signal?.addEventListener("abort", cancelNative, { once: true });
+			throwIfAborted(options.signal);
+			const value = await native.generateImage?.(request);
+			throwIfAborted(options.signal);
+			return imageResult(value, model, fallbackMetadata);
+		} finally {
+			subscription?.remove();
+			options.signal?.removeEventListener("abort", cancelNative);
 		}
-	};
-}
-function messagesFromInput(input) {
-	if (input.messages) {
-		if (input.system !== void 0 || input.prompt !== void 0) throw new AIError("invalid_message", "messages cannot be combined with system or prompt");
-		if (!input.messages.length) throw new AIError("invalid_message", "Expected at least one message");
-		return input.messages;
-	}
-	if (!input.prompt?.trim()) throw new AIError("invalid_message", "Expected prompt");
-	return [...input.system ? [{
-		role: "system",
-		content: input.system
-	}] : [], {
-		role: "user",
-		content: input.prompt
-	}];
+	} catch (error) {
+		if (error instanceof ImageGenerationError) throw error;
+		if (error instanceof AIError) throw error;
+		if (options.signal?.aborted) throw new AIError("generation_canceled", "Image generation canceled", error);
+		const mapped = mapNativeError(error);
+		if (mapped.code === "generation_failed" || mapped.code === "image_generation_failed") throw new ImageGenerationError(nativeErrorStage(error) ?? "denoise", nativeErrorMessage(error), error);
+		throw mapped;
+	}
 }
-function formatMessages(messages) {
-	if (messages[0]?.role === "assistant") throw new AIError("invalid_message", "Conversation cannot begin with assistant");
-	const parts = messages.map((message, index) => {
-		if (!message.content.trim()) throw new AIError("invalid_message", `Message ${index + 1} is empty`);
-		if (message.role === "system" && index !== 0) throw new AIError("invalid_message", "System message must be first");
-		return `<|im_start|>${message.role}\n${message.content}<|im_end|>\n`;
-	});
-	parts.push("<|im_start|>assistant\n<think>\n\n</think>\n\n");
-	return parts.join("");
+async function generateImages(options) {
+	const { count,...imageOptions } = options;
+	const results = [];
+	for (const seed of batchImageSeeds(count, options.seed)) {
+		throwIfAborted(options.signal);
+		results.push(await generateImage({
+			...imageOptions,
+			seed
+		}));
+	}
+	return results;
 }
-function endTokenIds(model) {
-	return model === "ternary-bonsai-27b" ? [248044, 248046] : [151643, 151645];
+const imageJobManagerKey = Symbol.for("bleam.ai.imageJobManager.v2");
+function imageJobManager() {
+	const scope = globalThis;
+	const manager = scope[imageJobManagerKey] ?? new ImageJobManager(new CollectionImageJobRepository(), generateImage);
+	manager.setExecutor(generateImage);
+	scope[imageJobManagerKey] = manager;
+	return manager;
+}
+async function queueImage(options) {
+	return imageJobManager().queue(options);
+}
+const image = Object.freeze({
+	generate: generateImage,
+	generateMany: generateImages,
+	queue: queueImage,
+	upscale: upscaleImage
+});
+const jobs = Object.freeze({
+	get: (id) => imageJobManager().get(id),
+	list: () => imageJobManager().list(),
+	cancel: (id) => imageJobManager().cancel(id),
+	retry: (id) => imageJobManager().retry(id),
+	resume: (id) => imageJobManager().resume(id),
+	remove: (id) => imageJobManager().remove(id)
+});
+function useJob(id) {
+	return useManagedJob(imageJobManager(), id);
+}
+function useJobList() {
+	return useManagedJobList(imageJobManager());
 }
 
 //#endregion
-//#region src/ai/text.ts
-function promptFromInput(options) {
-	const parts = [];
-	if (options.prompt) parts.push(options.prompt);
-	if (typeof options.input === "string") parts.push(options.input);
-	else if (options.input) parts.push(stableStringify(validateStructuredInput(options.input)));
-	if (parts.length === 0) throw new AIError("invalid_message", "Expected prompt or input");
-	return parts.join("\n\n");
-}
-async function isAvailable(model, options = {}) {
-	if (model) return (await availability(model, options)).available;
-	try {
-		return await bridge().isAvailable?.() ?? false;
-	} catch {
-		return false;
-	}
+//#region src/ai/image-composer.tsx
+const defaultImageSize = defaultImageLongSide;
+const defaultStepCount = 4;
+const minOutpaintScale = .35;
+const maxOutpaintScale = .95;
+function roundImageDimension(value) {
+	return normalizeImageSize({
+		width: value,
+		height: value
+	}, false).width;
 }
-async function availability(model, options = {}) {
-	if (model) {
-		const state = await verifyBonsaiTextModel(model, options);
-		if (!state.installed) return {
-			available: false,
-			reason: "not_installed"
-		};
-		if (!state.verified) return {
-			available: false,
-			reason: "invalid_model"
-		};
-		return { available: true };
-	}
-	try {
-		return await bridge().availability?.() ?? {
-			available: false,
-			reason: "unknown"
-		};
-	} catch {
-		return {
-			available: false,
-			reason: "unknown"
-		};
-	}
+function imageSizeForAspectRatio(size, maxSide = defaultImageSize) {
+	if (size.width <= 0 || size.height <= 0) return {
+		width: maxSide,
+		height: maxSide
+	};
+	const aspect = size.width / size.height;
+	return normalizeImageSize({
+		width: aspect >= 1 ? maxSide : maxSide * aspect,
+		height: aspect >= 1 ? maxSide / aspect : maxSide
+	}, maxSide);
 }
-function generationId() {
-	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+function roundedImageSize(size) {
+	return normalizeImageSize(size);
 }
-function nativeRequest(options, id) {
-	if (options.temperature !== void 0 && (!Number.isFinite(options.temperature) || options.temperature < 0)) throw new AIError("invalid_message", "temperature must be a non-negative number");
-	if (options.maxTokens !== void 0 && (!Number.isInteger(options.maxTokens) || options.maxTokens <= 0)) throw new AIError("invalid_message", "maxTokens must be a positive integer");
-	const names = /* @__PURE__ */ new Set();
-	for (const tool of options.tools ?? []) {
-		if (!tool.name.trim()) throw new AIError("invalid_schema", "Tool names must not be empty");
-		if (names.has(tool.name)) throw new AIError("invalid_schema", `Duplicate tool name: ${tool.name}`);
-		names.add(tool.name);
-	}
+function clamp(value, min$1, max) {
+	return Math.min(max, Math.max(min$1, value));
+}
+function clampOutpaintRect(rect) {
+	const width = Math.min(defaultImageSize, Math.max(1, Math.round(rect.width)));
+	const height = Math.min(defaultImageSize, Math.max(1, Math.round(rect.height)));
 	return {
-		id,
-		system: options.system,
-		prompt: promptFromInput(options),
-		temperature: options.temperature,
-		maxTokens: options.maxTokens,
-		outputSchema: options.output ? schemaToBridgeSchema(options.output) : void 0,
-		tools: options.tools?.map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			inputSchema: schemaToBridgeSchema(tool.input)
-		}))
+		x: Math.round(clamp(rect.x, 0, defaultImageSize - width)),
+		y: Math.round(clamp(rect.y, 0, defaultImageSize - height)),
+		width,
+		height
 	};
 }
-function listenForTools(id, tools) {
-	if (!tools?.length) return void 0;
-	const native = bridge();
-	return native.addListener?.("toolCall", (event) => {
-		if (event.generationId !== id) return;
-		const tool = tools.find((candidate) => candidate.name === event.name);
-		(async () => {
-			try {
-				if (!tool) throw new Error(`Unknown tool: ${event.name}`);
-				const validation = tool.input["~standard"].validate(event.arguments);
-				if (validation.issues !== void 0) throw new Error(validation.issues.map((issue$1) => issue$1.message).join("\n"));
-				const output = await tool.execute(validation.value);
-				await native.resolveToolCall?.({
-					generationId: id,
-					callId: event.callId,
-					output: typeof output === "string" ? output : stableStringify(output)
-				});
-			} catch (error) {
-				await native.resolveToolCall?.({
-					generationId: id,
-					callId: event.callId,
-					error: error instanceof Error ? error.message : String(error)
-				});
-			}
-		})();
-	});
-}
-async function generate(options) {
-	const output = options.output;
-	const id = generationId();
-	const native = bridge();
-	const toolSubscription = listenForTools(id, "tools" in options ? options.tools : void 0);
-	const abort = () => void native.cancelTextGeneration?.(id);
-	options.signal?.addEventListener("abort", abort, { once: true });
-	try {
-		if (options.signal?.aborted) throw new AIError("generation_canceled", "Generation canceled");
-		if (options.model) {
-			const prepared = await prepareBonsaiGeneration({
-				id,
-				model: options.model,
-				path: options.path,
-				system: options.system,
-				prompt: options.prompt,
-				messages: options.messages,
-				temperature: options.temperature,
-				maxTokens: options.maxTokens,
-				seed: options.seed
-			});
-			if (options.signal?.aborted) throw new AIError("generation_canceled", "Generation canceled");
-			const tokenIds = await native.generateLocalText?.(prepared.request);
-			if (!tokenIds) throw new AIError("unsupported_runtime", "Local text generation is unavailable in this runtime");
-			return prepared.decode(tokenIds);
-		}
-		const value = await native.generate?.(nativeRequest(options, id));
-		if (output) {
-			const result = output["~standard"].validate(value);
-			if (result.issues !== void 0) throw new AIError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
-			return result.value;
-		}
-		if (typeof value !== "string") throw new AIError("generation_failed", "Expected generated text");
-		return value;
-	} catch (error) {
-		if (error instanceof AIError) throw error;
-		throw mapNativeError(error);
-	} finally {
-		options.signal?.removeEventListener("abort", abort);
-		toolSubscription?.remove();
-	}
-}
-async function* stream(options) {
-	if (options.model) {
-		yield* streamBonsai(options);
-		return;
-	}
-	const id = generationId();
-	const native = bridge();
-	const updates = [];
-	let wake;
-	let settled = false;
-	let failure;
-	const updateSubscription = native.addListener?.("textGenerationUpdate", (event) => {
-		if (event.id !== id) return;
-		updates.push(event.content);
-		wake?.();
-		wake = void 0;
-	});
-	const toolSubscription = listenForTools(id, options.tools);
-	const abort = () => void native.cancelTextGeneration?.(id);
-	options.signal?.addEventListener("abort", abort, { once: true });
-	const completion = native.streamGenerate?.(nativeRequest(options, id)).catch((error) => {
-		failure = error;
-	}).finally(() => {
-		settled = true;
-		wake?.();
-		wake = void 0;
+function rectForSourceScale(sourceSize, scale, center) {
+	const aspect = sourceSize.width / sourceSize.height;
+	const longSide = defaultImageSize * clamp(scale, minOutpaintScale, maxOutpaintScale);
+	const width = aspect >= 1 ? longSide : longSide * aspect;
+	const height = aspect >= 1 ? longSide / aspect : longSide;
+	const nextCenter = center ?? {
+		x: defaultImageSize / 2,
+		y: defaultImageSize / 2
+	};
+	return clampOutpaintRect({
+		x: nextCenter.x - width / 2,
+		y: nextCenter.y - height / 2,
+		width,
+		height
 	});
-	try {
-		if (!completion) throw new AIError("unsupported_runtime", "Streaming is unavailable in this runtime");
-		while (!settled || updates.length > 0) if (updates.length > 0) yield updates.shift();
-		else await new Promise((resolve) => {
-			wake = resolve;
-		});
-		await completion;
-		if (failure) throw mapNativeError(failure);
-	} finally {
-		if (!settled) await native.cancelTextGeneration?.(id);
-		options.signal?.removeEventListener("abort", abort);
-		updateSubscription?.remove();
-		toolSubscription?.remove();
-	}
 }
-async function* streamBonsai(options) {
-	const id = generationId();
-	const native = bridge();
-	if (options.signal?.aborted) throw new AIError("generation_canceled", "Generation canceled");
-	const prepared = await prepareBonsaiGeneration({
-		id,
-		model: options.model,
-		path: options.path,
-		system: options.system,
-		prompt: options.prompt,
-		messages: options.messages,
-		temperature: options.temperature,
-		maxTokens: options.maxTokens,
-		seed: options.seed
-	});
-	if (options.signal?.aborted) throw new AIError("generation_canceled", "Generation canceled");
-	const updates = [];
-	let wake;
-	let settled = false;
-	let failure;
-	const updateSubscription = native.addListener?.("localTextGenerationUpdate", (event) => {
-		if (event.id !== id) return;
-		updates.push(event.tokenIds);
-		wake?.();
-		wake = void 0;
-	});
-	const abort = () => void native.cancelTextGeneration?.(id);
-	options.signal?.addEventListener("abort", abort, { once: true });
-	const completion = native.streamLocalText?.(prepared.request).catch((error) => {
-		failure = error;
-		return [];
-	}).finally(() => {
-		settled = true;
-		wake?.();
-		wake = void 0;
-	});
-	try {
-		if (!completion) throw new AIError("unsupported_runtime", "Local text streaming is unavailable in this runtime");
-		while (!settled || updates.length > 0) if (updates.length > 0) yield prepared.decode(updates.shift());
-		else await new Promise((resolve) => {
-			wake = resolve;
-		});
-		await completion;
-		if (failure) throw mapNativeError(failure);
-	} finally {
-		if (!settled) await native.cancelTextGeneration?.(id);
-		options.signal?.removeEventListener("abort", abort);
-		updateSubscription?.remove();
-	}
+function initialOutpaintRect(sourceSize) {
+	return rectForSourceScale(sourceSize, .72);
 }
-
-//#endregion
-//#region src/ai/text-hook.ts
-const initialState = {
-	text: "",
-	isGenerating: false,
-	error: null
-};
-function useTextGeneration() {
-	const [state, setState] = (0, react.useState)(initialState);
-	const abortControllerRef = (0, react.useRef)(null);
-	async function run(options) {
-		if (abortControllerRef.current) return null;
-		const abortController = new AbortController();
-		const abort = () => abortController.abort();
-		abortControllerRef.current = abortController;
-		options.signal?.addEventListener("abort", abort, { once: true });
-		if (options.signal?.aborted) abortController.abort();
-		setState({
-			text: "",
-			isGenerating: true,
-			error: null
-		});
-		let text = "";
-		try {
-			for await (const snapshot of stream({
-				...options,
-				signal: abortController.signal
-			})) {
-				text = snapshot;
-				setState({
-					text,
-					isGenerating: true,
-					error: null
-				});
-			}
-			setState({
-				text,
-				isGenerating: false,
-				error: null
-			});
-			return text;
-		} catch (error) {
-			setState({
-				text,
-				isGenerating: false,
-				error: error instanceof Error ? error : new Error(String(error))
-			});
-			return null;
-		} finally {
-			options.signal?.removeEventListener("abort", abort);
-			if (abortControllerRef.current === abortController) abortControllerRef.current = null;
-		}
+function buildImageGenerationRequest(input, options = {}) {
+	const base = {
+		prompt: input.prompt,
+		mode: input.mode,
+		steps: defaultStepCount,
+		guidance: 1,
+		...options
+	};
+	if (input.mode === "text") {
+		const references = (input.refs ?? []).map((image$1) => image$1.path);
+		return {
+			...base,
+			references: references.length > 0 ? references : void 0,
+			referenceInfluences: references.length > 0 ? references.map(() => 1) : void 0,
+			strength: references.length > 0 ? 1 : void 0,
+			width: defaultImageSize,
+			height: defaultImageSize
+		};
 	}
-	function cancel() {
-		abortControllerRef.current?.abort();
+	if (input.mode === "subject") {
+		if (!input.subject) throw new Error("Subject mode requires a subject image");
+		const refs = input.refs ?? [];
+		const references = [input.subject, ...refs].map((image$1) => image$1.path);
+		const size = imageSizeForAspectRatio(input.subject.size);
+		return {
+			...base,
+			references,
+			referenceInfluences: references.map(() => 1),
+			strength: 1,
+			width: size.width,
+			height: size.height
+		};
 	}
-	function clear() {
-		if (abortControllerRef.current) return;
-		setState(initialState);
+	if (input.mode === "edit") {
+		if (!input.source) throw new Error("Edit requires a source image");
+		const references = (input.refs ?? []).map((image$1) => image$1.path);
+		const size = roundedImageSize(input.source.size);
+		return {
+			...base,
+			image: input.source.path,
+			references: references.length > 0 ? references : void 0,
+			referenceInfluences: references.length > 0 ? references.map(() => 1) : void 0,
+			strength: references.length > 0 ? 1 : .35,
+			width: size.width,
+			height: size.height
+		};
 	}
+	if (!input.source) throw new Error("Outpaint requires a source image");
+	if (!input.rect) throw new Error("Outpaint requires a source placement");
 	return {
-		...state,
-		run,
-		cancel,
-		clear
+		...base,
+		image: input.source.path,
+		outpaint: {
+			width: defaultImageSize,
+			height: defaultImageSize,
+			sourceRect: input.rect,
+			autoCrop: true
+		},
+		strength: .8,
+		width: defaultImageSize,
+		height: defaultImageSize
 	};
 }
 
 //#endregion
 exports.AIError = AIError;
 exports.ImageGenerationError = ImageGenerationError;
-exports.availability = availability;
 exports.bonsai = bonsai;
 exports.bonsaiTextModelCatalog = bonsaiTextModelCatalog;
 exports.buildImageGenerationRequest = buildImageGenerationRequest;
+exports.chat = chat;
 exports.clampOutpaintRect = clampOutpaintRect;
 exports.defaultImageLongSide = defaultImageLongSide;
 exports.deleteImageLoRA = deleteImageLoRA;
@@ -4658,18 +4808,14 @@ exports.deleteImageModel = deleteImageModel;
 exports.deleteTextModel = deleteBonsaiTextModel;
 exports.flux2Klein4B8BitAbliterated = flux2Klein4B8BitAbliterated;
 exports.fluxImageModelPaths = fluxImageModelPaths;
-exports.generate = generate;
-exports.generateImage = generateImage;
-exports.generateImages = generateImages;
-exports.getImageGenerationJob = getImageGenerationJob;
+exports.image = image;
 exports.imageMemoryTelemetry = imageMemoryTelemetry;
 exports.imageModelManifest = imageModelManifest;
 exports.imageModelManifests = imageModelManifests;
 exports.imageSizeForAspectRatio = imageSizeForAspectRatio;
 exports.imageSizeForPreset = imageSizeForPreset;
 exports.initialOutpaintRect = initialOutpaintRect;
-exports.isAvailable = isAvailable;
-exports.listImageGenerationJobs = listImageGenerationJobs;
+exports.jobs = jobs;
 exports.listImageLoRAs = listImageLoRAs;
 exports.listImageModels = listImageModels;
 exports.listTextModels = listBonsaiTextModels;
@@ -4680,16 +4826,12 @@ exports.prepareTextModel = prepareBonsaiTextModel;
 exports.rectForSourceScale = rectForSourceScale;
 exports.roundImageDimension = roundImageDimension;
 exports.roundedImageSize = roundedImageSize;
-exports.scheduleImageGeneration = scheduleImageGeneration;
-exports.shape = shape;
-exports.stream = stream;
 exports.ternaryBonsaiImage4B = ternaryBonsaiImage4B;
 exports.unloadImageModel = unloadImageModel;
-exports.upscaleImage = upscaleImage;
-exports.useImageComposer = useImageComposer;
-exports.useImageGeneration = useImageGeneration;
-exports.useImageModel = useImageModel;
-exports.useTextGeneration = useTextGeneration;
+exports.useChat = useChat;
+exports.useChatList = useChatList;
+exports.useJob = useJob;
+exports.useJobList = useJobList;
 exports.verifyImageLoRA = verifyImageLoRA;
 exports.verifyImageModel = verifyImageModel;
 exports.verifyTextModel = verifyBonsaiTextModel;