bleam 0.0.11 → 0.0.12

package/dist/ai.js

@@ -1,11 +1,10 @@
 import "./native-runtime-C85Nuc4F.js";
 import "./crypto-BB92-Upx.js";
-import { i as files } from "./files-Ds1wT8C2.js";
-import { f as atom, p as useAtom } from "./state-CAwe-Vw1.js";
-import "./schema-Bo5Jvqus.js";
+import { a as nativeCopy, i as files } from "./files-BXVkPrPN.js";
+import { c as object, s as number, u as string } from "./schema-B5BfdswF.js";
+import { a as transactionAtom, d as internalJotaiWritableAtom, f as internalStore, g as currentAppStorageKey, i as queryAtom, n as atomCollection, r as mutateAtom, u as internalJotaiAtom } from "./state-Dh3HLixb.js";
 import { requireNativeModule } from "expo";
-import { useRef, useState } from "react";
-import { Image } from "react-native";
+import { use, useSyncExternalStore } from "react";
 
 //#region src/ai/bonsai.ts
 const internalTextModelCatalog = [
@@ -305,486 +304,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 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;
@@ -869,7 +726,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;
@@ -2591,16 +2448,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;
@@ -2796,1849 +2653,2142 @@ 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 files.file(state.path, "tokenizer.json").json(), await 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 files.directory(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 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: string({ default: "New Chat" }),
+	status: string({ default: "ready" })
 };
-function normalizedDimension(value) {
-	return Math.max(minimumImageDimension, Math.floor(value / imageDimensionMultiple) * imageDimensionMultiple);
+const errorShape = {
+	name: string(),
+	message: string(),
+	code: string(),
+	stage: string()
+};
+const messageShape = {
+	chatId: string(),
+	role: string(),
+	status: string(),
+	content: string({ default: "" }),
+	attempt: number({ default: 1 }),
+	sequence: number(),
+	error: object(errorShape),
+	startedAt: string(),
+	completedAt: string()
+};
+const chats = atomCollection("__bleam_ai_chats", chatShape);
+const chatMessages = atomCollection("__bleam_ai_chat_messages", messageShape);
+var CollectionChatRepository = class {
+	async create(input) {
+		const insert = mutateAtom(chats, (mutation) => mutation.insert());
+		const id = await internalStore.set(internalJotaiWritableAtom(insert), {
+			title: input.title ?? "New Chat",
+			status: "ready"
+		});
+		return this.requireChat(id);
+	}
+	async get(id) {
+		const row = queryAtom(chats, (query) => query.row(id));
+		return chatFromRow(await internalStore.get(internalJotaiAtom(row)));
+	}
+	async list() {
+		const ids = queryAtom(chats, (query) => query.sortBy("updatedAt", "desc").ids());
+		const values = await internalStore.get(internalJotaiAtom(ids));
+		return Promise.all(values.map((id) => this.requireChat(id)));
+	}
+	async messages(chatId) {
+		const ids = queryAtom(chatMessages, (query) => query.where({ chatId }).sortBy("sequence").ids());
+		const values = await internalStore.get(internalJotaiAtom(ids));
+		return (await Promise.all(values.map((id) => this.messageRow(id)))).flatMap((row) => row ? [messageFromRow(row)] : []);
+	}
+	async acceptSend(chatId, content) {
+		const transaction = 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 internalStore.set(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 = mutateAtom(chatMessages, (mutation) => mutation.update(message.id));
+		return messageFromRow(await internalStore.set(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 = mutateAtom(chats, (mutation) => mutation.update(id));
+		return chatFromRow(await internalStore.set(internalJotaiWritableAtom(update), { title }));
+	}
+	async remove(id) {
+		const transaction = 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 internalStore.set(internalJotaiWritableAtom(transaction));
+	}
+	async recoverActive() {
+		const transaction = 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 internalStore.set(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 = queryAtom(chatMessages, (query) => query.row(id));
+		return internalStore.get(internalJotaiAtom(row));
+	}
+	async transition(chatId, messageId, action) {
+		const transaction = 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 internalStore.set(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();
+	use(manager.ready);
+	const snapshot = 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();
+	use(manager.ready);
+	return 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 files.directory(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: string({ default: "paused" }),
+	request: string({ default: "{}" }),
+	progress: string({ default: "" }),
+	result: string({ default: "" }),
+	error: string({ default: "" }),
+	attempt: number({ default: 1 }),
+	startedAt: string({ default: "" }),
+	completedAt: string({ default: "" })
+};
+var CollectionImageJobRepository = class {
+	records = atomCollection("__bleam_ai_jobs", jobShape);
+	insertRecord = mutateAtom(this.records, (mutation) => mutation.insert());
+	async list() {
+		const ids = await internalStore.get(internalJotaiAtom(this.records));
+		return (await Promise.all(ids.map((id) => this.getRow(id)))).flatMap((row) => row ? [jobFromRow(row)] : []);
+	}
+	async insert(job) {
+		const id = await internalStore.set(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 = mutateAtom(this.records, (mutation) => mutation.update(job.id));
+		return jobFromRow(await internalStore.set(internalJotaiWritableAtom(updateRecord), dataFromJob(job)));
+	}
+	async remove(id) {
+		const removeRecord = mutateAtom(this.records, (mutation) => mutation.remove(id));
+		await internalStore.set(internalJotaiWritableAtom(removeRecord));
+	}
+	async getRow(id) {
+		const row = queryAtom(this.records, (query) => query.row(id));
+		return internalStore.get(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 = 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 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 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 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) {
+	use(manager.ready);
+	return useSyncExternalStore((listener) => manager.subscribeJob(id, listener), () => manager.getJobSnapshot(id));
+}
+function useManagedJobList(manager) {
+	use(manager.ready);
+	return 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 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 files.file(paths.textEncoderPath, "tokenizer.json").json(), await 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 files.directory(files.paths.shared, "ImageJobs", 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 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 ? 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 = 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 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 ? files.directory(options.directory, definition.manifest.directory).path : modelPathFromOptions(definition, void 0));
-	}))];
+function modelCacheRoot(manifest) {
+	return files.directory(files.paths.models, manifest.directory);
 }
-async function deleteImageModel(options = {}) {
-	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
-	await 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 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" ? 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 files.directory(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 = 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 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 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 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 files.file(paths.textEncoderPath, "tokenizer.json").json(), await 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] = 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] = 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] = 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] = 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 ? 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 = 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 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 ? files.directory(options.directory, definition.manifest.directory).path : modelPathFromOptions(definition, void 0));
+	}))];
+}
+async function deleteImageModel(options = {}) {
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	await 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] = 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] = 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 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] = 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" ? 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 ??= atom(initialValue);
-	return ref.current;
-}
-function useStableRef(initialValue) {
-	return 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 files.directory(inputRoot ?? files.paths.shared, "ImageGenerationInputs", String(Date.now()));
-}
-async function pickOneImage(inputRoot) {
-	const [picked] = await 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 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) => {
-		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 files.file(state.path, "tokenizer.json").json(), await 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] = useState(initialState);
-	const abortControllerRef = 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
-export { AIError, ImageGenerationError, availability, bonsai, bonsaiTextModelCatalog, buildImageGenerationRequest, clampOutpaintRect, defaultImageLongSide, deleteImageLoRA, deleteImageModel, deleteBonsaiTextModel as deleteTextModel, flux2Klein4B8BitAbliterated, fluxImageModelPaths, generate, generateImage, generateImages, getImageGenerationJob, imageMemoryTelemetry, imageModelManifest, imageModelManifests, imageSizeForAspectRatio, imageSizeForPreset, initialOutpaintRect, isAvailable, listImageGenerationJobs, listImageLoRAs, listImageModels, listBonsaiTextModels as listTextModels, normalizeImageSize, prepareImageLoRA, prepareImageModel, prepareBonsaiTextModel as prepareTextModel, rectForSourceScale, roundImageDimension, roundedImageSize, scheduleImageGeneration, shape, stream, ternaryBonsaiImage4B, unloadImageModel, upscaleImage, useImageComposer, useImageGeneration, useImageModel, useTextGeneration, verifyImageLoRA, verifyImageModel, verifyBonsaiTextModel as verifyTextModel };
+export { AIError, ImageGenerationError, bonsai, bonsaiTextModelCatalog, buildImageGenerationRequest, chat, clampOutpaintRect, defaultImageLongSide, deleteImageLoRA, deleteImageModel, deleteBonsaiTextModel as deleteTextModel, flux2Klein4B8BitAbliterated, fluxImageModelPaths, image, imageMemoryTelemetry, imageModelManifest, imageModelManifests, imageSizeForAspectRatio, imageSizeForPreset, initialOutpaintRect, jobs, listImageLoRAs, listImageModels, listBonsaiTextModels as listTextModels, normalizeImageSize, prepareImageLoRA, prepareImageModel, prepareBonsaiTextModel as prepareTextModel, rectForSourceScale, roundImageDimension, roundedImageSize, ternaryBonsaiImage4B, unloadImageModel, useChat, useChatList, useJob, useJobList, verifyImageLoRA, verifyImageModel, verifyBonsaiTextModel as verifyTextModel };