bleam 0.0.10 → 0.0.12

package/dist/ai.cjs

@@ -1,16 +1,61 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
 require('./native-runtime-CsXnXkQn.cjs');
 require('./crypto-CT3VZ7lF.cjs');
-const require_files = require('./files-Bo7h9fik.cjs');
-const require_state = require('./state-Bx0VlTlO.cjs');
-require('./schema-rQ13mrpD.cjs');
+const require_files = require('./files-DxaQ-Nv0.cjs');
+const require_schema = require('./schema-BnVZOXfu.cjs');
+const require_state = require('./state-LssDgpff.cjs');
 let expo = require("expo");
 expo = require_chunk.__toESM(expo);
 let react = require("react");
 react = require_chunk.__toESM(react);
-let react_native = require("react-native");
-react_native = require_chunk.__toESM(react_native);
 
+//#region src/ai/bonsai.ts
+const internalTextModelCatalog = [
+	{
+		id: "ternary-bonsai-1.7b",
+		repo: "prism-ml/Ternary-Bonsai-1.7B-mlx-2bit",
+		revision: "5f3e306330f636cfc6c6241b4850fae6711c5985",
+		estimatedDownloadBytes: 495528947,
+		contextLength: 32768,
+		architecture: "qwen3"
+	},
+	{
+		id: "ternary-bonsai-4b",
+		repo: "prism-ml/Ternary-Bonsai-4B-mlx-2bit",
+		revision: "e1374ad6bf9b1b56afd743936b8faa33c409a75f",
+		estimatedDownloadBytes: 1143060044,
+		contextLength: 32768,
+		architecture: "qwen3"
+	},
+	{
+		id: "ternary-bonsai-8b",
+		repo: "prism-ml/Ternary-Bonsai-8B-mlx-2bit",
+		revision: "9260b24298e4211e804663e9f519962cf59f34be",
+		estimatedDownloadBytes: 2315155948,
+		contextLength: 65536,
+		architecture: "qwen3"
+	},
+	{
+		id: "ternary-bonsai-27b",
+		repo: "prism-ml/Ternary-Bonsai-27B-mlx-2bit",
+		revision: "70f75f3ad081ab840a42f3304c02c27e7f89bfb7",
+		estimatedDownloadBytes: 8510972679,
+		contextLength: 262144,
+		architecture: "qwen3.5"
+	}
+];
+const bonsaiTextModelCatalog = Object.freeze(internalTextModelCatalog.map(({ architecture: _,...metadata }) => Object.freeze(metadata)));
+function bonsai(id) {
+	const text = internalTextModelCatalog.some((model) => model.id === id);
+	if (!text && id !== "ternary-bonsai-image-4b") throw new TypeError(`Unsupported Bonsai model: ${id}`);
+	return Object.freeze({
+		provider: "bonsai",
+		kind: text ? "text" : "image",
+		id
+	});
+}
+
+//#endregion
 //#region src/ai/errors.ts
 var AIError = class extends Error {
 	constructor(code, message, cause) {
@@ -51,312 +96,500 @@ function mapNativeError(error) {
 }
 
 //#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);
+//#region src/ai/bonsai-text.ts
+const bonsaiTextModelFiles = [
+	"config.json",
+	"tokenizer.json",
+	"tokenizer_config.json",
+	"chat_template.jinja",
+	"model.safetensors",
+	"model.safetensors.index.json"
+];
+function modelId(model) {
+	return typeof model === "string" ? model : model.id;
+}
+function metadataFor(model) {
+	const id = modelId(model);
+	const metadata = bonsaiTextModelCatalog.find((candidate) => candidate.id === id);
+	if (!metadata) throw new AIError("invalid_model", `Unsupported Bonsai text model: ${id}`);
+	return metadata;
+}
+function bonsaiTextModelDirectory(model) {
+	return require_files.files.directory(require_files.files.paths.models, "bonsai", "text", modelId(model));
+}
+function modelDirectory(model, override) {
+	return override ? require_files.files.directory(override) : bonsaiTextModelDirectory(model);
+}
+function modelDirectoryIn(model, directory) {
+	return directory ? require_files.files.directory(directory, modelId(model)) : bonsaiTextModelDirectory(model);
+}
+function resolveUrl(repo, revision, file) {
+	return `https://huggingface.co/${repo.split("/").map(encodeURIComponent).join("/")}/resolve/${encodeURIComponent(revision)}/${encodeURIComponent(file)}`;
+}
+function throwIfAborted$1(signal) {
+	if (signal?.aborted) throw new AIError("generation_canceled", "Bonsai model preparation canceled");
+}
+const fileSizes = {
+	"ternary-bonsai-1.7b": {
+		"config.json": 2939,
+		"tokenizer.json": 11422650,
+		"tokenizer_config.json": 348,
+		"chat_template.jinja": 4063,
+		"model.safetensors": 484049216,
+		"model.safetensors.index.json": 49731
+	},
+	"ternary-bonsai-4b": {
+		"config.json": 3115,
+		"tokenizer.json": 11422650,
+		"tokenizer_config.json": 348,
+		"chat_template.jinja": 4063,
+		"model.safetensors": 1131565944,
+		"model.safetensors.index.json": 63924
+	},
+	"ternary-bonsai-8b": {
+		"config.json": 3118,
+		"tokenizer.json": 11422650,
+		"tokenizer_config.json": 348,
+		"chat_template.jinja": 4063,
+		"model.safetensors": 2303661704,
+		"model.safetensors.index.json": 64065
+	},
+	"ternary-bonsai-27b": {
+		"config.json": 3790,
+		"tokenizer.json": 19989343,
+		"tokenizer_config.json": 1098,
+		"chat_template.jinja": 7764,
+		"model.safetensors": 8490785104,
+		"model.safetensors.index.json": 185580
+	}
+};
+function validFile(model, file, size) {
+	return size === fileSizes[model][file];
+}
+async function stateFor(model, rootOverride) {
+	const metadata = metadataFor(model);
+	const root = modelDirectory(model, rootOverride);
+	const missingFiles = [];
+	const invalidFiles = [];
+	let bytesPresent = 0;
+	for (const file of bonsaiTextModelFiles) {
+		const stat = await root.file(file).stat();
+		if (stat.type !== "file") missingFiles.push(file);
+		else {
+			bytesPresent += stat.size ?? 0;
+			if (!validFile(metadata.id, file, stat.size)) invalidFiles.push(file);
+		}
+	}
+	const expectedRevision = metadata.revision;
+	const manifestFile = root.file("manifest.json");
+	if ((await manifestFile.stat()).type !== "file") missingFiles.push("manifest.json");
+	else try {
+		const manifest = await manifestFile.json();
+		if (!isRecord(manifest) || manifest.formatVersion !== 1 || manifest.model !== metadata.id || manifest.revision !== expectedRevision) invalidFiles.push("manifest.json");
+	} catch {
+		invalidFiles.push("manifest.json");
+	}
+	if (!missingFiles.includes("config.json")) try {
+		const config = await root.file("config.json").json();
+		if (!validConfig(metadata.id, config)) invalidFiles.push("config.json");
+	} catch {
+		invalidFiles.push("config.json");
+	}
+	const installed = missingFiles.length === 0;
+	return {
+		model: bonsai(metadata.id),
+		metadata,
+		path: root.path,
+		installed,
+		verified: installed && invalidFiles.length === 0,
+		bytesPresent,
+		estimatedTotalBytes: metadata.estimatedDownloadBytes,
+		missingFiles,
+		invalidFiles
+	};
+}
+function validConfig(model, value) {
+	if (!isRecord(value)) return false;
+	const expected = {
+		"ternary-bonsai-1.7b": [
+			2048,
+			28,
+			32768
+		],
+		"ternary-bonsai-4b": [
+			2560,
+			36,
+			32768
+		],
+		"ternary-bonsai-8b": [
+			4096,
+			36,
+			65536
+		],
+		"ternary-bonsai-27b": [
+			5120,
+			64,
+			262144
+		]
+	}[model];
+	const config = model === "ternary-bonsai-27b" ? value.text_config : value;
+	if (!isRecord(config)) return false;
+	const quantization = config.quantization;
+	return isRecord(quantization) && quantization.bits === 2 && quantization.group_size === 128 && config.hidden_size === expected[0] && config.num_hidden_layers === expected[1] && config.max_position_embeddings === expected[2];
+}
+async function prepareBonsaiTextModel(model, options = {}) {
+	const metadata = metadataFor(model);
+	const root = modelDirectoryIn(model, options.directory);
+	throwIfAborted$1(options.signal);
+	await root.create({ recursive: true });
+	const headers = options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0;
+	const completedBytes = /* @__PURE__ */ new Map();
+	const emit = (file, index, progress) => {
+		completedBytes.set(file, progress.bytesWritten);
+		const modelBytesWritten = Array.from(completedBytes.values()).reduce((total, bytes) => total + bytes, 0);
+		options.onProgress?.({
+			model: metadata.id,
+			file,
+			index,
+			total: bonsaiTextModelFiles.length,
+			...progress,
+			modelBytesWritten,
+			estimatedModelBytes: metadata.estimatedDownloadBytes,
+			modelFraction: Math.min(1, modelBytesWritten / metadata.estimatedDownloadBytes)
+		});
+	};
+	for (const [fileIndex, file] of bonsaiTextModelFiles.entries()) {
+		throwIfAborted$1(options.signal);
+		const index = fileIndex + 1;
+		const destination = root.file(file);
+		const expectedBytes = fileSizes[metadata.id][file];
+		const stat = await destination.stat();
+		if (stat.type === "file" && validFile(metadata.id, file, stat.size)) {
+			emit(file, index, {
+				bytesWritten: stat.size ?? 0,
+				totalBytes: stat.size,
+				fraction: 1
+			});
+			continue;
+		}
+		await destination.download(resolveUrl(metadata.repo, metadata.revision, file), {
+			headers,
+			expectedBytes,
+			atomic: true,
+			resume: true,
+			signal: options.signal,
+			onProgress(progress) {
+				emit(file, index, progress);
+			}
+		}).result;
+		throwIfAborted$1(options.signal);
+	}
+	await root.file("manifest.json").write(JSON.stringify({
+		formatVersion: 1,
+		model: metadata.id,
+		revision: metadata.revision
+	}));
+	const state = await stateFor(metadata.id, root.path);
+	if (!state.verified) throw new AIError("invalid_model", `Downloaded Bonsai model is incomplete: ${[...state.missingFiles, ...state.invalidFiles].join(", ")}`);
+	return {
+		model: state.model,
+		path: root.path
+	};
+}
+function verifyBonsaiTextModel(model, options = {}) {
+	return stateFor(model, options.path);
+}
+function listBonsaiTextModels(options = {}) {
+	return Promise.all(bonsaiTextModelCatalog.map((metadata) => stateFor(metadata.id, options.directory ? require_files.files.directory(options.directory, metadata.id).path : void 0)));
+}
+async function deleteBonsaiTextModel(model, options = {}) {
+	await modelDirectory(model, options.path).delete({ recursive: true });
 }
 
 //#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
+		});
 	}
-};
-function canceledError(cause) {
-	return new AIError("generation_canceled", "Image generation canceled", cause);
-}
-
-//#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"
-			]
-		}
+	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();
 	}
 };
-const imageModelManifests = [flux2Klein4B8BitAbliterated];
-function imageModelManifest(model) {
-	return imageModelManifests.find((manifest) => manifest.model === model);
+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
+	}))];
 }
-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);
-function joinModelPath(root, component) {
-	return `${root.replace(/\/+$/, "")}/${component.replace(/^\/+/, "")}`;
+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 fluxImageModelPaths(modelRoot, manifest = flux2Klein4B8BitAbliterated) {
+function serializeError(error) {
+	const value = error instanceof Error ? error : new Error(String(error));
+	const details = value;
 	return {
-		modelRoot,
-		textEncoderPath: joinModelPath(modelRoot, manifest.components.textEncoder.path),
-		transformerPath: joinModelPath(modelRoot, manifest.components.transformer.path),
-		vaePath: joinModelPath(modelRoot, manifest.components.vae.path)
+		name: value.name,
+		message: value.message,
+		code: typeof details.code === "string" ? details.code : void 0,
+		stage: typeof details.stage === "string" ? details.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];
-}
-
-//#endregion
-//#region src/ai/image-upscale.ts
-function normalizeUpscaleScale(value) {
-	const scale = value ?? 2;
-	if (!Number.isFinite(scale) || scale <= 1 || scale > 4) throw new AIError("invalid_model", "Upscale scale must be greater than 1 and at most 4");
-	return scale;
-}
-
-//#endregion
-//#region src/ai/native.ts
-function bridge() {
-	try {
-		return (0, expo.requireNativeModule)("AI");
-	} catch (error) {
-		throw new AIError("unsupported_runtime", "bleam/ai requires the Bleam native runtime", error);
-	}
-}
+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/tokenizers.mjs
@@ -496,7 +729,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;
@@ -2218,16 +2451,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;
@@ -2422,16 +2655,1266 @@ var Tokenizer = class {
 };
 var Tokenizer_default = Tokenizer;
 
+//#endregion
+//#region src/ai/bonsai-generation.ts
+async function prepareBonsaiGeneration(input) {
+	const state = await verifyBonsaiTextModel(input.model, { path: input.path });
+	if (!state.verified) throw new AIError("model_unavailable", `${input.model.id} is not prepared. Call prepareTextModel() before generation.`);
+	const tokenizer = new Tokenizer_default(await require_files.files.file(state.path, "tokenizer.json").json(), await require_files.files.file(state.path, "tokenizer_config.json").json());
+	const inputIds = tokenizer.encode(formatMessages(messagesFromInput(input))).ids.map(Number);
+	if (!inputIds.length || inputIds.some((token) => !Number.isInteger(token))) throw new AIError("invalid_message", "Tokenizer returned invalid token ids");
+	return {
+		request: {
+			id: input.id,
+			model: input.model.id,
+			modelPath: state.path,
+			inputIds,
+			endTokenIds: endTokenIds(input.model.id),
+			maxTokens: input.maxTokens,
+			temperature: input.temperature,
+			seed: input.seed
+		},
+		decode(tokenIds) {
+			return tokenIds.length ? tokenizer.decode(tokenIds, { skip_special_tokens: true }) : "";
+		}
+	};
+}
+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 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 endTokenIds(model) {
+	return model === "ternary-bonsai-27b" ? [248044, 248046] : [151643, 151645];
+}
+
+//#endregion
+//#region src/ai/native.ts
+function bridge() {
+	try {
+		return (0, expo.requireNativeModule)("AI");
+	} catch (error) {
+		throw new AIError("unsupported_runtime", "bleam/ai requires the Bleam native runtime", error);
+	}
+}
+
+//#endregion
+//#region src/ai/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;
+	});
+	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();
+	}
+}
+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();
+	}
+}
+
+//#endregion
+//#region src/ai/chat.tsx
+const chatShape = {
+	title: require_schema.string({ default: "New Chat" }),
+	status: require_schema.string({ default: "ready" })
+};
+const errorShape = {
+	name: require_schema.string(),
+	message: require_schema.string(),
+	code: require_schema.string(),
+	stage: require_schema.string()
+};
+const messageShape = {
+	chatId: require_schema.string(),
+	role: require_schema.string(),
+	status: require_schema.string(),
+	content: require_schema.string({ default: "" }),
+	attempt: require_schema.number({ default: 1 }),
+	sequence: require_schema.number(),
+	error: require_schema.object(errorShape),
+	startedAt: require_schema.string(),
+	completedAt: require_schema.string()
+};
+const chats = require_state.atomCollection("__bleam_ai_chats", chatShape);
+const chatMessages = require_state.atomCollection("__bleam_ai_chat_messages", messageShape);
+var CollectionChatRepository = class {
+	async create(input) {
+		const insert = require_state.mutateAtom(chats, (mutation) => mutation.insert());
+		const id = await require_state.internalStore.set(require_state.internalJotaiWritableAtom(insert), {
+			title: input.title ?? "New Chat",
+			status: "ready"
+		});
+		return this.requireChat(id);
+	}
+	async get(id) {
+		const row = require_state.queryAtom(chats, (query) => query.row(id));
+		return chatFromRow(await require_state.internalStore.get(require_state.internalJotaiAtom(row)));
+	}
+	async list() {
+		const ids = require_state.queryAtom(chats, (query) => query.sortBy("updatedAt", "desc").ids());
+		const values = await require_state.internalStore.get(require_state.internalJotaiAtom(ids));
+		return Promise.all(values.map((id) => this.requireChat(id)));
+	}
+	async messages(chatId) {
+		const ids = require_state.queryAtom(chatMessages, (query) => query.where({ chatId }).sortBy("sequence").ids());
+		const values = await require_state.internalStore.get(require_state.internalJotaiAtom(ids));
+		return (await Promise.all(values.map((id) => this.messageRow(id)))).flatMap((row) => row ? [messageFromRow(row)] : []);
+	}
+	async acceptSend(chatId, content) {
+		const transaction = require_state.transactionAtom(async (tx) => {
+			const chat$1 = await tx.get(chats, chatId);
+			if (!chat$1) throw new Error(`Chat not found: ${chatId}`);
+			if (isActiveStatus(chat$1.data.status)) throw new Error("This chat already has an active generation");
+			const previousIds = await tx.query(chatMessages, (query) => query.where({ chatId }).sortBy("sequence", "desc").take(1).ids());
+			const sequence = ((previousIds[0] ? await tx.get(chatMessages, previousIds[0]) : null)?.data.sequence ?? 0) + 1;
+			const userId = await tx.insert(chatMessages, {
+				chatId,
+				role: "user",
+				status: "completed",
+				content,
+				attempt: 1,
+				sequence,
+				completedAt: timestamp()
+			});
+			const assistantId = await tx.insert(chatMessages, {
+				chatId,
+				role: "assistant",
+				status: "queued",
+				content: "",
+				attempt: 1,
+				sequence: sequence + 1
+			});
+			return acceptedFromTransaction(tx, await tx.update(chats, chatId, { status: "queued" }), assistantId, userId);
+		});
+		return require_state.internalStore.set(require_state.internalJotaiWritableAtom(transaction));
+	}
+	async start(chatId, messageId) {
+		return this.transition(chatId, messageId, async (tx, _chat, message) => {
+			if (message.data.status !== "queued") throw new Error("Only queued messages can start");
+			const startedAt = timestamp();
+			const assistant = await tx.update(chatMessages, messageId, {
+				status: "generating",
+				startedAt
+			});
+			return acceptedFromTransaction(tx, await tx.update(chats, chatId, { status: "generating" }), assistant.id);
+		});
+	}
+	async updateContent(message) {
+		const update = require_state.mutateAtom(chatMessages, (mutation) => mutation.update(message.id));
+		return messageFromRow(await require_state.internalStore.set(require_state.internalJotaiWritableAtom(update), { content: message.content }));
+	}
+	async markCanceling(chatId, messageId) {
+		return this.transition(chatId, messageId, async (tx, _chat, message) => {
+			if (!isActiveStatus(message.data.status ?? "")) throw new Error("Message is not active");
+			const assistant = await tx.update(chatMessages, messageId, { status: "canceling" });
+			return acceptedFromTransaction(tx, await tx.update(chats, chatId, { status: "canceling" }), assistant.id);
+		});
+	}
+	async finish(chatId, messageId, status, content, error) {
+		return this.transition(chatId, messageId, async (tx, _chat) => {
+			const completedAt = timestamp();
+			const assistant = await tx.update(chatMessages, messageId, {
+				status,
+				content,
+				error,
+				completedAt
+			});
+			return acceptedFromTransaction(tx, await tx.update(chats, chatId, { status: status === "completed" ? "ready" : status }), assistant.id);
+		});
+	}
+	async retry(chatId, messageId) {
+		return this.transition(chatId, messageId, async (tx, _chat, message) => {
+			const ids = await tx.query(chatMessages, (query) => query.where({ chatId }).sortBy("sequence", "desc").ids());
+			const rows = await Promise.all(ids.map((id) => tx.get(chatMessages, id)));
+			if (rows.find((row) => row?.data.role === "assistant")?.id !== messageId) throw new Error("Only the latest assistant message can be retried");
+			if (message.data.status !== "failed" && message.data.status !== "canceled") throw new Error("Only failed or canceled messages can be retried");
+			const assistant = await tx.update(chatMessages, messageId, {
+				status: "queued",
+				content: "",
+				attempt: message.data.attempt + 1,
+				error: void 0,
+				startedAt: void 0,
+				completedAt: void 0
+			});
+			const nextChat = await tx.update(chats, chatId, { status: "queued" });
+			const user = rows.find((row) => row?.data.role === "user" && (row.data.sequence ?? 0) < (assistant.data.sequence ?? 0));
+			return acceptedFromTransaction(tx, nextChat, assistant.id, user?.id);
+		});
+	}
+	async setTitle(id, title) {
+		const update = require_state.mutateAtom(chats, (mutation) => mutation.update(id));
+		return chatFromRow(await require_state.internalStore.set(require_state.internalJotaiWritableAtom(update), { title }));
+	}
+	async remove(id) {
+		const transaction = require_state.transactionAtom(async (tx) => {
+			const chat$1 = await tx.get(chats, id);
+			if (!chat$1) return false;
+			if (isActiveStatus(chat$1.data.status)) throw new Error("Active chats cannot be removed");
+			const ids = await tx.query(chatMessages, (query) => query.where({ chatId: id }).ids());
+			for (const messageId of ids) await tx.remove(chatMessages, messageId);
+			return tx.remove(chats, id);
+		});
+		return require_state.internalStore.set(require_state.internalJotaiWritableAtom(transaction));
+	}
+	async recoverActive() {
+		const transaction = require_state.transactionAtom(async (tx) => {
+			const chatIds = await tx.query(chats, (query) => query.ids());
+			for (const chatId of chatIds) {
+				const chat$1 = await tx.get(chats, chatId);
+				if (!chat$1) continue;
+				const messageIds = await tx.query(chatMessages, (query) => query.where({ chatId }).ids());
+				let recoveredMessage = false;
+				for (const messageId of messageIds) {
+					const message = await tx.get(chatMessages, messageId);
+					if (message?.data.role === "assistant" && isActiveStatus(message.data.status ?? "")) {
+						await tx.update(chatMessages, messageId, {
+							status: "canceled",
+							error: recoveryError(),
+							completedAt: timestamp()
+						});
+						recoveredMessage = true;
+					}
+				}
+				if (recoveredMessage || isActiveStatus(chat$1.data.status)) await tx.update(chats, chatId, { status: "canceled" });
+			}
+		});
+		await require_state.internalStore.set(require_state.internalJotaiWritableAtom(transaction));
+	}
+	async requireChat(id) {
+		const chat$1 = await this.get(id);
+		if (!chat$1) throw new Error(`Chat not found: ${id}`);
+		return chat$1;
+	}
+	async messageRow(id) {
+		const row = require_state.queryAtom(chatMessages, (query) => query.row(id));
+		return require_state.internalStore.get(require_state.internalJotaiAtom(row));
+	}
+	async transition(chatId, messageId, action) {
+		const transaction = require_state.transactionAtom(async (tx) => {
+			const chat$1 = await tx.get(chats, chatId);
+			const message = await tx.get(chatMessages, messageId);
+			if (!chat$1) throw new Error(`Chat not found: ${chatId}`);
+			if (!message || message.data.chatId !== chatId) throw new Error(`Message not found: ${messageId}`);
+			return action(tx, chat$1, message);
+		});
+		return require_state.internalStore.set(require_state.internalJotaiWritableAtom(transaction));
+	}
+};
+const managerKey = Symbol.for("bleam.ai.chatManager.v1");
+function managedChats() {
+	const scope = globalThis;
+	scope[managerKey] ??= new ChatManager(new CollectionChatRepository(), { stream(options) {
+		return streamChat(options);
+	} });
+	return scope[managerKey];
+}
+const chat = {
+	create(input = {}) {
+		return managedChats().create(input);
+	},
+	get(id) {
+		return managedChats().get(id);
+	},
+	list() {
+		return managedChats().list();
+	},
+	send(id, content, options) {
+		return managedChats().send(id, content, options);
+	},
+	cancel(id) {
+		return managedChats().cancel(id);
+	},
+	retry(id, messageId, options) {
+		return managedChats().retry(id, messageId, options);
+	},
+	setTitle(id, title) {
+		return managedChats().setTitle(id, title);
+	},
+	remove(id) {
+		return managedChats().remove(id);
+	}
+};
+function useChat(id, options = {}) {
+	const manager = managedChats();
+	(0, react.use)(manager.ready);
+	const snapshot = (0, react.useSyncExternalStore)((listener) => manager.subscribeChat(id, listener), () => manager.getChatSnapshot(id));
+	const generationOptions = optionsWithoutCallbacks(options);
+	const callbacks = {
+		onFinish: options.onFinish,
+		onError: options.onError
+	};
+	const status = snapshot.chat?.status ?? "not-found";
+	const active = status === "queued" || status === "generating" || status === "canceling";
+	const error = snapshot.messages.findLast((message) => message.role === "assistant")?.error;
+	return {
+		chat: snapshot.chat,
+		messages: snapshot.messages,
+		status,
+		error: error ?? null,
+		isGenerating: active,
+		canSend: snapshot.chat !== null && !active,
+		canCancel: status === "queued" || status === "generating",
+		send: (content, invocation) => manager.send(id, content, mergeOptions(generationOptions, invocation), callbacks),
+		cancel: () => manager.cancel(id),
+		retry: (messageId, invocation) => manager.retry(id, messageId, mergeOptions(generationOptions, invocation), callbacks),
+		setTitle: (title) => manager.setTitle(id, title),
+		remove: () => manager.remove(id)
+	};
+}
+function useChatList() {
+	const manager = managedChats();
+	(0, react.use)(manager.ready);
+	return (0, react.useSyncExternalStore)((listener) => manager.subscribeList(listener), () => manager.getListSnapshot());
+}
+async function acceptedFromTransaction(tx, chatRow, assistantId, userId) {
+	const ids = await tx.query(chatMessages, (query) => query.where({ chatId: chatRow.id }).sortBy("sequence").ids());
+	const messages = (await Promise.all(ids.map((id) => tx.get(chatMessages, id)))).flatMap((row) => row ? [messageFromRow(row)] : []);
+	const assistantMessage = messages.find((message) => message.id === assistantId);
+	if (assistantMessage?.role !== "assistant") throw new Error(`Assistant message not found: ${assistantId}`);
+	const userMessage = userId ? messages.find((message) => message.id === userId) : void 0;
+	return {
+		chatId: chatRow.id,
+		userMessageId: userMessage?.id ?? "",
+		assistantMessageId: assistantId,
+		chat: chatFromRow(chatRow),
+		userMessage,
+		assistantMessage,
+		messages
+	};
+}
+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 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 optionsWithoutCallbacks(options) {
+	const { onFinish: _onFinish, onError: _onError,...generation } = options;
+	return generation;
+}
+function mergeOptions(defaults, invocation) {
+	return {
+		...defaults,
+		...invocation
+	};
+}
+function isActiveStatus(status) {
+	return status === "queued" || status === "generating" || status === "canceling";
+}
+function recoveryError() {
+	return {
+		name: "AIError",
+		code: "generation_canceled",
+		message: "Generation was interrupted when the app exited"
+	};
+}
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+//#endregion
+//#region src/ai/image-batch.ts
+function batchImageSeeds(count, seed) {
+	if (!Number.isInteger(count) || count < 1 || count > 64) throw new AIError("invalid_message", "Batch count must be an integer from 1 to 64");
+	const first = seed ?? Math.floor(Math.random() * 4294967296);
+	return Array.from({ length: count }, (_, index) => first + index >>> 0);
+}
+
+//#endregion
+//#region src/ai/image-jobs.ts
+const jobShape = {
+	status: require_schema.string({ default: "paused" }),
+	request: require_schema.string({ default: "{}" }),
+	progress: require_schema.string({ default: "" }),
+	result: require_schema.string({ default: "" }),
+	error: require_schema.string({ default: "" }),
+	attempt: require_schema.number({ default: 1 }),
+	startedAt: require_schema.string({ default: "" }),
+	completedAt: require_schema.string({ default: "" })
+};
+var CollectionImageJobRepository = class {
+	records = require_state.atomCollection("__bleam_ai_jobs", jobShape);
+	insertRecord = require_state.mutateAtom(this.records, (mutation) => mutation.insert());
+	async list() {
+		const ids = await require_state.internalStore.get(require_state.internalJotaiAtom(this.records));
+		return (await Promise.all(ids.map((id) => this.getRow(id)))).flatMap((row) => row ? [jobFromRow(row)] : []);
+	}
+	async insert(job) {
+		const id = await require_state.internalStore.set(require_state.internalJotaiWritableAtom(this.insertRecord), dataFromJob(job));
+		const row = await this.getRow(id);
+		if (!row) throw new Error(`Could not load inserted image job ${id}`);
+		return jobFromRow(row);
+	}
+	async update(job) {
+		const updateRecord = require_state.mutateAtom(this.records, (mutation) => mutation.update(job.id));
+		return jobFromRow(await require_state.internalStore.set(require_state.internalJotaiWritableAtom(updateRecord), dataFromJob(job)));
+	}
+	async remove(id) {
+		const removeRecord = require_state.mutateAtom(this.records, (mutation) => mutation.remove(id));
+		await require_state.internalStore.set(require_state.internalJotaiWritableAtom(removeRecord));
+	}
+	async getRow(id) {
+		const row = require_state.queryAtom(this.records, (query) => query.row(id));
+		return require_state.internalStore.get(require_state.internalJotaiAtom(row));
+	}
+};
+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;
+		}
+	}
+	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;
+		});
+	}
+	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);
+		}
+		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;
+			}
+		}
+	}
+	nextQueued() {
+		return [...this.records.values()].filter((job) => job.status === "queued").sort((left, right) => left.createdAt === right.createdAt ? left.id.localeCompare(right.id) : left.createdAt.localeCompare(right.createdAt))[0];
+	}
+	async replace(job, update) {
+		const persisted = await this.repository.update({
+			...job,
+			...update
+		});
+		this.set(persisted);
+		return persisted;
+	}
+	set(job) {
+		this.records.set(job.id, job);
+		this.refreshList();
+		this.emit(job.id);
+	}
+	refreshList() {
+		this.listSnapshot = [...this.records.values()].sort((left, right) => left.createdAt === right.createdAt ? right.id.localeCompare(left.id) : right.createdAt.localeCompare(left.createdAt)).map(summaryFromJob);
+		for (const listener of this.listListeners) listener();
+	}
+	emit(id) {
+		for (const listener of this.jobListeners.get(id) ?? []) listener();
+	}
+};
+function useManagedJob(manager, id) {
+	(0, react.use)(manager.ready);
+	return (0, react.useSyncExternalStore)((listener) => manager.subscribeJob(id, listener), () => manager.getJobSnapshot(id));
+}
+function useManagedJobList(manager) {
+	(0, react.use)(manager.ready);
+	return (0, react.useSyncExternalStore)((listener) => manager.subscribeList(listener), () => manager.getListSnapshot());
+}
+const nativeImageJobFiles = {
+	async prepare(id, request) {
+		const inputs = jobRoot(id).directory("Inputs");
+		await inputs.create();
+		return {
+			...request,
+			image: request.image ? await copyInput(request.image, inputs.path, "Image") : void 0,
+			mask: request.mask ? await copyInput(request.mask, inputs.path, "Mask") : void 0,
+			references: request.references ? await Promise.all(request.references.map((reference, index) => copyInput(reference, inputs.path, `Reference-${index + 1}`))) : void 0,
+			loras: request.loras ? await Promise.all(request.loras.map(async (lora, index) => lora.source.type === "local" ? {
+				...lora,
+				source: {
+					...lora.source,
+					path: await copyInput(lora.source.path, inputs.path, `LoRA-${index + 1}`, ".safetensors")
+				}
+			} : lora)) : void 0
+		};
+	},
+	async remove(job) {
+		await jobRoot(job.id).delete().catch(() => void 0);
+		if (job.result?.uri) await require_files.files.file(pathFromUri(job.result.uri)).delete().catch(() => void 0);
+	}
+};
+function dataFromJob(job) {
+	return {
+		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 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}`);
+}
+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 canceledError(message = "Image generation canceled") {
+	return {
+		name: "AIError",
+		code: "generation_canceled",
+		message
+	};
+}
+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 jobRoot(id) {
+	return require_files.files.directory(require_files.files.paths.shared, "ImageJobs", require_state.currentAppStorageKey(), id);
+}
+async function copyInput(source, directory, name, fallbackExtension = ".png") {
+	const path = pathFromUri(source);
+	const destination = `${directory}/${name}${path.match(/\.[A-Za-z0-9]+$/)?.[0] ?? fallbackExtension}`;
+	await require_files.nativeCopy(path, destination);
+	return destination;
+}
+function pathFromUri(value) {
+	if (!value.startsWith("file://")) return value;
+	try {
+		return decodeURIComponent(new URL(value).pathname);
+	} catch {
+		return value.slice(7);
+	}
+}
+function now() {
+	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"
+			]
+		}
+	}
+};
+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);
+}
+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/image.ts
-function modelCacheRoot(manifest = flux2Klein4B8BitAbliterated) {
+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
+	};
+	throw new AIError("invalid_model", `Unsupported image model: ${id}`);
+}
+function modelCacheRoot(manifest) {
 	return require_files.files.directory(require_files.files.paths.models, manifest.directory);
 }
 function assertImageModel(model) {
-	if (model !== flux2Klein4B8BitAbliterated.model) throw new AIError("invalid_model", `Unsupported image model: ${model}`);
+	imageModelDefinition(model);
 }
-function modelRootFromOptions(modelRoot) {
-	return modelRoot ?? modelCacheRoot().path;
+function modelPathFromOptions(definition, path) {
+	return path ?? modelCacheRoot(definition.manifest).path;
 }
 function downloadConcurrency(value) {
 	if (value === void 0) return 2;
@@ -2598,11 +4081,11 @@ function cachedLoRAFile(lora) {
 	return imageLoRARoot().directory(id).file(safeCacheName(sourceFileName(lora), "lora filename"));
 }
 async function ensureModelFile(input) {
-	const destination = require_files.files.file(input.modelRoot, input.file.destination);
+	const destination = require_files.files.file(input.path, input.file.destination);
 	const stat = await destination.stat();
 	if (stat.type === "file" && stat.size === input.file.bytes) {
 		input.onProgress?.({
-			model: flux2Klein4B8BitAbliterated.model,
+			model: input.model,
 			file: input.file.destination,
 			index: input.index,
 			total: input.total,
@@ -2619,7 +4102,7 @@ async function ensureModelFile(input) {
 		resume: true,
 		onProgress(progress) {
 			input.onProgress?.({
-				model: flux2Klein4B8BitAbliterated.model,
+				model: input.model,
 				file: input.file.destination,
 				index: input.index,
 				total: input.total,
@@ -2628,16 +4111,16 @@ async function ensureModelFile(input) {
 		}
 	}).result;
 }
-async function writePreparedManifest(modelRoot) {
-	await require_files.files.file(modelRoot, "manifest.json").write(JSON.stringify(flux2Klein4B8BitAbliterated, null, 2));
+async function writePreparedManifest(path, manifest) {
+	await require_files.files.file(path, "manifest.json").write(JSON.stringify(manifest, null, 2));
 }
-async function imageModelState(model, modelRoot) {
-	assertImageModel(model);
+async function imageModelState(model, path) {
+	const definition = imageModelDefinition(model);
 	let bytesPresent = 0;
 	const missingFiles = [];
 	const invalidFiles = [];
-	for (const file of flux2KleinModelFiles) {
-		const stat = await require_files.files.file(modelRoot, file.destination).stat();
+	for (const file of definition.files) {
+		const stat = await require_files.files.file(path, file.destination).stat();
 		if (stat.type !== "file") {
 			missingFiles.push(file.destination);
 			continue;
@@ -2645,17 +4128,17 @@ async function imageModelState(model, modelRoot) {
 		bytesPresent += Math.min(stat.size ?? 0, file.bytes);
 		if (stat.size !== file.bytes) invalidFiles.push(file.destination);
 	}
-	const installed = missingFiles.length === 0;
-	const manifestStat = await require_files.files.file(modelRoot, "manifest.json").stat();
+	const manifestStat = await require_files.files.file(path, "manifest.json").stat();
 	if (manifestStat.type !== "file") missingFiles.push("manifest.json");
+	const installed = missingFiles.length === 0;
 	return {
 		model,
-		modelRoot,
-		paths: fluxImageModelPaths(modelRoot),
+		path,
+		paths: fluxImageModelPaths(path, definition.manifest),
 		installed,
 		verified: installed && invalidFiles.length === 0 && manifestStat.type === "file",
 		bytesPresent,
-		totalBytes: flux2KleinTotalBytes,
+		totalBytes: definition.totalBytes,
 		missingFiles,
 		invalidFiles
 	};
@@ -2665,13 +4148,13 @@ function tokenArray(value, name) {
 	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;
+		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;
 	});
 }
-async function createFluxTokenizer(modelRoot) {
-	const paths = fluxImageModelPaths(modelRoot);
+async function createFluxTokenizer(path, manifest) {
+	const paths = fluxImageModelPaths(path, manifest);
 	const tokenizer = new Tokenizer_default(await require_files.files.file(paths.textEncoderPath, "tokenizer.json").json(), await require_files.files.file(paths.textEncoderPath, "tokenizer_config.json").json());
 	const padTokenId = 151643;
 	return ({ prompt, maxLength }) => {
@@ -2718,18 +4201,18 @@ 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, fallbackMetadata) {
-	if (!isRecord(value) || typeof value.uri !== "string" || typeof value.width !== "number" || typeof value.height !== "number" || value.model !== "flux2-klein-4b-8bit-abliterated") throw new AIError("image_generation_failed", "Expected generated image URI");
+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: value.model,
+		model,
 		metadata: {
 			...fallbackMetadata,
-			model: metadata.model === value.model ? metadata.model : fallbackMetadata.model,
+			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,
@@ -2778,15 +4261,18 @@ function nativeErrorMessage(error) {
 	return (error instanceof Error ? error.message : String(error)).replace(/^\[(download|tokenize|encode|denoise|decode|write)]\s*/, "");
 }
 async function prepareImageModel(options = {}) {
-	const model = options.model ?? flux2Klein4B8BitAbliterated.model;
-	assertImageModel(model);
-	const root = modelCacheRoot();
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	return prepareImageModelAtPath(definition, options, options.directory ? require_files.files.directory(options.directory, definition.manifest.directory).path : modelCacheRoot(definition.manifest).path);
+}
+async function prepareImageModelAtPath(definition, options, path) {
+	const model = definition.manifest.model;
+	const root = require_files.files.directory(path);
 	await root.create({ recursive: true });
 	const headers = options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0;
-	const total = flux2KleinModelFiles.length;
+	const total = definition.files.length;
 	const bytesByFile = /* @__PURE__ */ new Map();
 	const emitProgress = (progress) => {
-		const file = flux2KleinModelFiles.find((candidate) => candidate.destination === progress.file);
+		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);
@@ -2794,12 +4280,12 @@ async function prepareImageModel(options = {}) {
 			...progress,
 			bytesWritten,
 			modelBytesWritten,
-			totalModelBytes: flux2KleinTotalBytes,
-			modelFraction: modelBytesWritten / flux2KleinTotalBytes
+			totalModelBytes: definition.totalBytes,
+			modelFraction: modelBytesWritten / definition.totalBytes
 		});
 	};
 	const missingFiles = [];
-	for (const [index, file] of flux2KleinModelFiles.entries()) {
+	for (const [index, file] of definition.files.entries()) {
 		const stat = await require_files.files.file(root.path, file.destination).stat();
 		if (stat.type === "file" && stat.size === file.bytes) emitProgress({
 			model,
@@ -2817,7 +4303,8 @@ async function prepareImageModel(options = {}) {
 	}
 	await runConcurrent(missingFiles, downloadConcurrency(options.concurrency), async ({ file, index }) => {
 		await ensureModelFile({
-			modelRoot: root.path,
+			model,
+			path: root.path,
 			file,
 			headers,
 			index,
@@ -2825,22 +4312,26 @@ async function prepareImageModel(options = {}) {
 			onProgress: emitProgress
 		});
 	});
-	await writePreparedManifest(root.path);
+	await writePreparedManifest(root.path, definition.manifest);
 	return {
 		model,
-		...fluxImageModelPaths(root.path),
-		tokenizer: await createFluxTokenizer(root.path)
+		...fluxImageModelPaths(root.path, definition.manifest),
+		tokenizer: await createFluxTokenizer(root.path, definition.manifest)
 	};
 }
 async function verifyImageModel(options = {}) {
-	return imageModelState(options.model ?? flux2Klein4B8BitAbliterated.model, modelRootFromOptions(options.modelRoot));
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	return imageModelState(definition.manifest.model, modelPathFromOptions(definition, options.path));
 }
 async function listImageModels(options = {}) {
-	return [await imageModelState(flux2Klein4B8BitAbliterated.model, modelRootFromOptions(options.modelRoot))];
+	return [...await Promise.all([flux2Klein4B8BitAbliterated.model, ternaryBonsaiImage4B.model].map((model) => {
+		const definition = imageModelDefinition(model);
+		return imageModelState(model, options.directory ? require_files.files.directory(options.directory, definition.manifest.directory).path : modelPathFromOptions(definition, void 0));
+	}))];
 }
 async function deleteImageModel(options = {}) {
-	assertImageModel(options.model ?? flux2Klein4B8BitAbliterated.model);
-	await require_files.files.directory(modelRootFromOptions(options.modelRoot)).delete({ recursive: true });
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	await require_files.files.directory(modelPathFromOptions(definition, options.path)).delete({ recursive: true });
 }
 async function imageMemoryTelemetry() {
 	const value = await bridge().imageMemoryTelemetry?.();
@@ -2978,8 +4469,8 @@ async function prepareSelectedImageLoRAs(loras, model, options = {}) {
 }
 async function generateImage(options) {
 	throwIfAborted(options.signal);
-	const model = options.model ?? flux2Klein4B8BitAbliterated.model;
-	assertImageModel(model);
+	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;
@@ -3038,16 +4529,16 @@ async function generateImage(options) {
 	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.modelRoot && options.tokenizer ? void 0 : await withImageStage("download", () => prepareImageModel({
+	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 modelRoot = options.modelRoot ?? prepared?.modelRoot;
-	if (!tokenizer || !modelRoot) throw new AIError("invalid_model", "Expected image model root and 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
@@ -3058,7 +4549,7 @@ async function generateImage(options) {
 		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(modelRoot);
+	const paths = fluxImageModelPaths(modelPath, definition.manifest);
 	const request = {
 		model,
 		prompt,
@@ -3088,7 +4579,10 @@ async function generateImage(options) {
 		seed,
 		inputIds: tokenized.inputIds,
 		attentionMask: tokenized.attentionMask,
-		...paths
+		modelRoot: paths.path,
+		textEncoderPath: paths.textEncoderPath,
+		transformerPath: paths.transformerPath,
+		vaePath: paths.vaePath
 	};
 	const fallbackMetadata = {
 		model,
@@ -3119,7 +4613,7 @@ async function generateImage(options) {
 			throwIfAborted(options.signal);
 			const value = await native.generateImage?.(request);
 			throwIfAborted(options.signal);
-			return imageResult(value, fallbackMetadata);
+			return imageResult(value, model, fallbackMetadata);
 		} finally {
 			subscription?.remove();
 			options.signal?.removeEventListener("abort", cancelNative);
@@ -3145,22 +4639,36 @@ async function generateImages(options) {
 	}
 	return results;
 }
-const imageGenerationQueueKey = Symbol.for("bleam.ai.imageGenerationQueue");
-function imageGenerationQueue() {
+const imageJobManagerKey = Symbol.for("bleam.ai.imageJobManager.v2");
+function imageJobManager() {
 	const scope = globalThis;
-	const queue = scope[imageGenerationQueueKey] ?? new ImageGenerationQueue(generateImage);
-	queue.setExecutor(generateImage);
-	scope[imageGenerationQueueKey] = queue;
-	return queue;
+	const manager = scope[imageJobManagerKey] ?? new ImageJobManager(new CollectionImageJobRepository(), generateImage);
+	manager.setExecutor(generateImage);
+	scope[imageJobManagerKey] = manager;
+	return manager;
 }
-function scheduleImageGeneration(options) {
-	return imageGenerationQueue().schedule(options);
+async function queueImage(options) {
+	return imageJobManager().queue(options);
 }
-function getImageGenerationJob(id) {
-	return imageGenerationQueue().get(id);
+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 listImageGenerationJobs() {
-	return imageGenerationQueue().list();
+function useJobList() {
+	return useManagedJobList(imageJobManager());
 }
 
 //#endregion
@@ -3230,7 +4738,7 @@ function buildImageGenerationRequest(input, options = {}) {
 		...options
 	};
 	if (input.mode === "text") {
-		const references = (input.refs ?? []).map((image) => image.path);
+		const references = (input.refs ?? []).map((image$1) => image$1.path);
 		return {
 			...base,
 			references: references.length > 0 ? references : void 0,
@@ -3243,7 +4751,7 @@ function buildImageGenerationRequest(input, options = {}) {
 	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 references = [input.subject, ...refs].map((image$1) => image$1.path);
 		const size = imageSizeForAspectRatio(input.subject.size);
 		return {
 			...base,
@@ -3256,7 +4764,7 @@ function buildImageGenerationRequest(input, options = {}) {
 	}
 	if (input.mode === "edit") {
 		if (!input.source) throw new Error("Edit requires a source image");
-		const references = (input.refs ?? []).map((image) => image.path);
+		const references = (input.refs ?? []).map((image$1) => image$1.path);
 		const size = roundedImageSize(input.source.size);
 		return {
 			...base,
@@ -3284,863 +4792,45 @@ function buildImageGenerationRequest(input, options = {}) {
 		height: defaultImageSize
 	};
 }
-function useImageComposer(modeOrOptions, options = {}) {
-	if (typeof modeOrOptions !== "string") return useImageComposerController(modeOrOptions ?? {});
-	const mode = modeOrOptions;
-	if (mode === "text") return useTextComposer(options);
-	if (mode === "subject") return useSubjectComposer(options);
-	if (mode === "edit") return useEditComposer(options);
-	return useOutpaintComposer(options);
-}
-function useImageComposerController(options) {
-	const [mode, setMode] = require_state.useAtom(useComposerAtom(options.initialMode ?? "text"));
-	const text = useTextComposer(options);
-	const subject = useSubjectComposer(options);
-	const edit = useEditComposer(options);
-	const outpaint = useOutpaintComposer(options);
-	const active = mode === "text" ? text : mode === "subject" ? subject : mode === "edit" ? edit : outpaint;
-	const error = active.error ?? text.error ?? subject.error ?? edit.error ?? outpaint.error;
-	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();
-		}
-	};
-}
-function useTextComposer(options) {
-	const store = useComposerAtom({
-		refs: [],
-		isPicking: false,
-		error: null
-	});
-	const [state, setState] = require_state.useAtom(store);
-	const maxRefs = options.maxRefs ?? 3;
-	async function pickRefs() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const refs = [...store.get().refs, ...await pickImages(options.inputRoot)].slice(0, maxRefs);
-			setState((current) => ({
-				...current,
-				refs,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	return {
-		mode: "text",
-		...state,
-		pickRefs,
-		removeRef: (index) => setState((current) => removeRefFromState(current, index)),
-		request: (prompt) => ({
-			mode: "text",
-			prompt,
-			refs: store.get().refs
-		}),
-		clear: () => setState({
-			refs: [],
-			isPicking: false,
-			error: null
-		})
-	};
-}
-function useSubjectComposer(options) {
-	const store = useComposerAtom({
-		subject: null,
-		refs: [],
-		isPicking: false,
-		error: null
-	});
-	const [state, setState] = require_state.useAtom(store);
-	const maxRefs = options.maxRefs ?? 2;
-	async function pickSubject() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const subject = await pickOneImage(options.inputRoot);
-			setState((current) => ({
-				...current,
-				subject: subject ?? current.subject,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	async function pickRefs() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const refs = [...store.get().refs, ...await pickImages(options.inputRoot)].slice(0, maxRefs);
-			setState((current) => ({
-				...current,
-				refs,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	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
-		})
-	};
-}
-function useEditComposer(options) {
-	const store = useComposerAtom({
-		source: null,
-		refs: [],
-		isPicking: false,
-		error: null
-	});
-	const [state, setState] = require_state.useAtom(store);
-	const maxRefs = options.maxRefs ?? 3;
-	async function pickSource() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const source = await pickOneImage(options.inputRoot);
-			setState((current) => ({
-				...current,
-				source: source ?? current.source,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	async function pickRefs() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const refs = [...store.get().refs, ...await pickImages(options.inputRoot)].slice(0, maxRefs);
-			setState((current) => ({
-				...current,
-				refs,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	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
-		})
-	};
-}
-function useOutpaintComposer(options) {
-	const store = useComposerAtom({
-		source: null,
-		rect: null,
-		isPicking: false,
-		error: null
-	});
-	const [state, setState] = require_state.useAtom(store);
-	async function pickSource() {
-		setState((current) => ({
-			...current,
-			isPicking: true,
-			error: null
-		}));
-		try {
-			const source = await pickOneImage(options.inputRoot);
-			setState((current) => ({
-				...current,
-				source: source ?? current.source,
-				rect: source ? initialOutpaintRect(source.size) : current.rect,
-				isPicking: false
-			}));
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				error: errorFromUnknown(error),
-				isPicking: false
-			}));
-		}
-	}
-	return {
-		mode: "outpaint",
-		...state,
-		pickSource,
-		removeSource: () => setState((current) => ({
-			...current,
-			source: null,
-			rect: null
-		})),
-		setRect: (rect) => setState((current) => ({
-			...current,
-			rect
-		})),
-		request: (prompt) => {
-			const current = store.get();
-			return {
-				mode: "outpaint",
-				prompt,
-				source: current.source,
-				rect: current.rect
-			};
-		},
-		clear: () => setState({
-			source: null,
-			rect: null,
-			isPicking: false,
-			error: null
-		})
-	};
-}
-function useImageGeneration() {
-	const [state, setState] = require_state.useAtom(useComposerAtom({
-		imageUri: null,
-		result: null,
-		progress: 0,
-		status: "",
-		isGenerating: false,
-		error: null
-	}));
-	const abortControllerRef = useStableRef(null);
-	async function run(input, options = {}) {
-		if (abortControllerRef.current) return null;
-		const abortController = new AbortController();
-		abortControllerRef.current = abortController;
-		setState((current) => ({
-			...current,
-			imageUri: null,
-			result: null,
-			progress: 0,
-			status: "Generating...",
-			isGenerating: true,
-			error: null
-		}));
-		try {
-			const result = await generateImage(buildImageGenerationRequest(input, {
-				...options,
-				signal: abortController.signal,
-				onModelProgress(progress) {
-					setState((current) => ({
-						...current,
-						progress: progress.modelFraction >= 1 ? .15 : progress.modelFraction * .15,
-						status: progress.modelFraction >= 1 ? "Generating..." : modelProgressStatus(progress)
-					}));
-				},
-				onProgress(progress) {
-					setState((current) => ({
-						...current,
-						progress: .15 + progress.currentStep / progress.totalSteps * .85,
-						status: `Step ${progress.currentStep}/${progress.totalSteps}`
-					}));
-				}
-			}));
-			setState((current) => ({
-				...current,
-				imageUri: result.uri,
-				result,
-				progress: 1,
-				status: `${result.metadata.width}×${result.metadata.height} • ${result.metadata.steps} steps`,
-				isGenerating: false
-			}));
-			return result;
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				status: error instanceof Error ? error.message : String(error),
-				error: errorFromUnknown(error),
-				isGenerating: false
-			}));
-			return null;
-		} finally {
-			if (abortControllerRef.current === abortController) abortControllerRef.current = null;
-		}
-	}
-	function cancel() {
-		setState((current) => ({
-			...current,
-			status: "Canceling..."
-		}));
-		abortControllerRef.current?.abort();
-	}
-	function clear() {
-		setState({
-			imageUri: null,
-			result: null,
-			progress: 0,
-			status: "",
-			isGenerating: false,
-			error: null
-		});
-	}
-	return {
-		...state,
-		run,
-		cancel,
-		clear
-	};
-}
-function useImageModel() {
-	const [state, setState] = require_state.useAtom(useComposerAtom({
-		checking: false,
-		state: null,
-		error: null
-	}));
-	async function check() {
-		setState((current) => ({
-			...current,
-			checking: true,
-			error: null
-		}));
-		try {
-			const [modelState] = await listImageModels();
-			setState({
-				checking: false,
-				state: modelState ?? null,
-				error: null
-			});
-			return modelState ?? null;
-		} catch (error) {
-			setState((current) => ({
-				...current,
-				checking: false,
-				error: errorFromUnknown(error)
-			}));
-			return null;
-		}
-	}
-	return {
-		...state,
-		installed: state.state?.installed ?? false,
-		verified: state.state?.verified ?? false,
-		missingFiles: state.state?.missingFiles ?? [],
-		bytesPresent: state.state?.bytesPresent ?? 0,
-		totalBytes: state.state?.totalBytes ?? 0,
-		check
-	};
-}
-function useComposerAtom(initialValue) {
-	const ref = useStableRef(null);
-	ref.current ??= require_state.atom(initialValue);
-	return ref.current;
-}
-function useStableRef(initialValue) {
-	return (0, react.useRef)(initialValue);
-}
-function removeRefFromState(state, index) {
-	return {
-		...state,
-		refs: state.refs.filter((_, i) => i !== index)
-	};
-}
-function inputDestination(inputRoot) {
-	return require_files.files.directory(inputRoot ?? require_files.files.paths.shared, "ImageGenerationInputs", String(Date.now()));
-}
-async function pickOneImage(inputRoot) {
-	const [picked] = await require_files.files.pick({
-		type: "image",
-		destination: inputDestination(inputRoot)
-	});
-	if (!picked) return null;
-	return Object.assign(picked, { size: await getImageSize(picked.uri) });
-}
-async function pickImages(inputRoot) {
-	const picked = await require_files.files.pick({
-		type: "image",
-		multiple: true,
-		destination: inputDestination(inputRoot)
-	});
-	return Promise.all(picked.map(async (image) => Object.assign(image, { size: await getImageSize(image.uri) })));
-}
-function getImageSize(uri) {
-	return new Promise((resolve, reject) => {
-		react_native.Image.getSize(uri, (width, height) => resolve({
-			width,
-			height
-		}), reject);
-	});
-}
-function errorFromUnknown(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-function modelProgressStatus(progress) {
-	return `Model ${Math.round(progress.modelFraction * 100)}% • ${formatBytes(progress.modelBytesWritten)} / ${formatBytes(progress.totalModelBytes)}`;
-}
-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;
-	}
-	return `${size.toFixed(size >= 10 ? 1 : 2)} ${units[index]}`;
-}
-
-//#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";
-	}
-};
-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);
-	}
-	return {
-		type: "object",
-		properties,
-		required
-	};
-}
-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);
-		}
-	};
-	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/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() {
-	try {
-		return await bridge().isAvailable?.() ?? false;
-	} catch {
-		return false;
-	}
-}
-async function availability() {
-	try {
-		return await bridge().availability?.() ?? {
-			available: false,
-			reason: "unknown"
-		};
-	} catch {
-		return {
-			available: false,
-			reason: "unknown"
-		};
-	}
-}
-function generationId() {
-	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-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);
-	}
-	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)
-		}))
-	};
-}
-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, options.tools);
-	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");
-		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) {
-	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;
-	});
-	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();
-	}
-}
-
-//#endregion
-//#region src/ai/text-hook.ts
-const initialState = {
-	text: "",
-	isGenerating: false,
-	error: null
-};
-function useTextGeneration() {
-	const [state, setState] = (0, react.useState)(initialState);
-	const abortControllerRef = (0, react.useRef)(null);
-	async function run(options) {
-		if (abortControllerRef.current) return null;
-		const abortController = new AbortController();
-		const abort = () => abortController.abort();
-		abortControllerRef.current = abortController;
-		options.signal?.addEventListener("abort", abort, { once: true });
-		if (options.signal?.aborted) abortController.abort();
-		setState({
-			text: "",
-			isGenerating: true,
-			error: null
-		});
-		let text = "";
-		try {
-			for await (const snapshot of stream({
-				...options,
-				signal: abortController.signal
-			})) {
-				text = snapshot;
-				setState({
-					text,
-					isGenerating: true,
-					error: null
-				});
-			}
-			setState({
-				text,
-				isGenerating: false,
-				error: null
-			});
-			return text;
-		} catch (error) {
-			setState({
-				text,
-				isGenerating: false,
-				error: error instanceof Error ? error : new Error(String(error))
-			});
-			return null;
-		} finally {
-			options.signal?.removeEventListener("abort", abort);
-			if (abortControllerRef.current === abortController) abortControllerRef.current = null;
-		}
-	}
-	function cancel() {
-		abortControllerRef.current?.abort();
-	}
-	function clear() {
-		if (abortControllerRef.current) return;
-		setState(initialState);
-	}
-	return {
-		...state,
-		run,
-		cancel,
-		clear
-	};
-}
 
 //#endregion
 exports.AIError = AIError;
 exports.ImageGenerationError = ImageGenerationError;
-exports.availability = availability;
+exports.bonsai = bonsai;
+exports.bonsaiTextModelCatalog = bonsaiTextModelCatalog;
 exports.buildImageGenerationRequest = buildImageGenerationRequest;
+exports.chat = chat;
 exports.clampOutpaintRect = clampOutpaintRect;
 exports.defaultImageLongSide = defaultImageLongSide;
 exports.deleteImageLoRA = deleteImageLoRA;
 exports.deleteImageModel = deleteImageModel;
+exports.deleteTextModel = deleteBonsaiTextModel;
 exports.flux2Klein4B8BitAbliterated = flux2Klein4B8BitAbliterated;
 exports.fluxImageModelPaths = fluxImageModelPaths;
-exports.generate = generate;
-exports.generateImage = generateImage;
-exports.generateImages = generateImages;
-exports.getImageGenerationJob = getImageGenerationJob;
+exports.image = image;
 exports.imageMemoryTelemetry = imageMemoryTelemetry;
 exports.imageModelManifest = imageModelManifest;
 exports.imageModelManifests = imageModelManifests;
 exports.imageSizeForAspectRatio = imageSizeForAspectRatio;
 exports.imageSizeForPreset = imageSizeForPreset;
 exports.initialOutpaintRect = initialOutpaintRect;
-exports.isAvailable = isAvailable;
-exports.listImageGenerationJobs = listImageGenerationJobs;
+exports.jobs = jobs;
 exports.listImageLoRAs = listImageLoRAs;
 exports.listImageModels = listImageModels;
+exports.listTextModels = listBonsaiTextModels;
 exports.normalizeImageSize = normalizeImageSize;
 exports.prepareImageLoRA = prepareImageLoRA;
 exports.prepareImageModel = prepareImageModel;
+exports.prepareTextModel = prepareBonsaiTextModel;
 exports.rectForSourceScale = rectForSourceScale;
 exports.roundImageDimension = roundImageDimension;
 exports.roundedImageSize = roundedImageSize;
-exports.scheduleImageGeneration = scheduleImageGeneration;
-exports.shape = shape;
-exports.stream = stream;
+exports.ternaryBonsaiImage4B = ternaryBonsaiImage4B;
 exports.unloadImageModel = unloadImageModel;
-exports.upscaleImage = upscaleImage;
-exports.useImageComposer = useImageComposer;
-exports.useImageGeneration = useImageGeneration;
-exports.useImageModel = useImageModel;
-exports.useTextGeneration = useTextGeneration;
+exports.useChat = useChat;
+exports.useChatList = useChatList;
+exports.useJob = useJob;
+exports.useJobList = useJobList;
 exports.verifyImageLoRA = verifyImageLoRA;
-exports.verifyImageModel = verifyImageModel;
+exports.verifyImageModel = verifyImageModel;
+exports.verifyTextModel = verifyBonsaiTextModel;