bleam 0.0.9 → 0.0.11

package/dist/ai.js

@@ -7,6 +7,53 @@ import { requireNativeModule } from "expo";
 import { useRef, useState } from "react";
 import { Image } from "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) {
@@ -46,6 +93,217 @@ function mapNativeError(error) {
 	return new AIError("generation_failed", message, error);
 }
 
+//#endregion
+//#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 files.directory(files.paths.models, "bonsai", "text", modelId(model));
+}
+function modelDirectory(model, override) {
+	return override ? files.directory(override) : bonsaiTextModelDirectory(model);
+}
+function modelDirectoryIn(model, directory) {
+	return directory ? 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 ? 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-batch.ts
 function batchImageSeeds(count, seed) {
@@ -243,7 +501,51 @@ const flux2Klein4B8BitAbliterated = {
 		}
 	}
 };
-const imageModelManifests = [flux2Klein4B8BitAbliterated];
+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);
 }
@@ -313,15 +615,90 @@ const flux2KleinModelFiles = [
 	}
 ];
 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(modelRoot, manifest = flux2Klein4B8BitAbliterated) {
+function fluxImageModelPaths(path, manifest = flux2Klein4B8BitAbliterated) {
 	return {
-		modelRoot,
-		textEncoderPath: joinModelPath(modelRoot, manifest.components.textEncoder.path),
-		transformerPath: joinModelPath(modelRoot, manifest.components.transformer.path),
-		vaePath: joinModelPath(modelRoot, manifest.components.vae.path)
+		path,
+		textEncoderPath: joinModelPath(path, manifest.components.textEncoder.path),
+		transformerPath: joinModelPath(path, manifest.components.transformer.path),
+		vaePath: joinModelPath(path, manifest.components.vae.path)
 	};
 }
 
@@ -2420,14 +2797,31 @@ var Tokenizer_default = Tokenizer;
 
 //#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 files.directory(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;
@@ -2594,11 +2988,11 @@ function cachedLoRAFile(lora) {
 	return imageLoRARoot().directory(id).file(safeCacheName(sourceFileName(lora), "lora filename"));
 }
 async function ensureModelFile(input) {
-	const destination = files.file(input.modelRoot, input.file.destination);
+	const destination = files.file(input.path, input.file.destination);
 	const stat = await destination.stat();
 	if (stat.type === "file" && stat.size === input.file.bytes) {
 		input.onProgress?.({
-			model: flux2Klein4B8BitAbliterated.model,
+			model: input.model,
 			file: input.file.destination,
 			index: input.index,
 			total: input.total,
@@ -2615,7 +3009,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,
@@ -2624,16 +3018,16 @@ async function ensureModelFile(input) {
 		}
 	}).result;
 }
-async function writePreparedManifest(modelRoot) {
-	await files.file(modelRoot, "manifest.json").write(JSON.stringify(flux2Klein4B8BitAbliterated, null, 2));
+async function writePreparedManifest(path, manifest) {
+	await 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 files.file(modelRoot, file.destination).stat();
+	for (const file of definition.files) {
+		const stat = await files.file(path, file.destination).stat();
 		if (stat.type !== "file") {
 			missingFiles.push(file.destination);
 			continue;
@@ -2641,17 +3035,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 files.file(modelRoot, "manifest.json").stat();
+	const manifestStat = await 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
 	};
@@ -2666,8 +3060,8 @@ function tokenArray(value, name) {
 		return number;
 	});
 }
-async function createFluxTokenizer(modelRoot) {
-	const paths = fluxImageModelPaths(modelRoot);
+async function createFluxTokenizer(path, manifest) {
+	const paths = fluxImageModelPaths(path, manifest);
 	const tokenizer = new Tokenizer_default(await files.file(paths.textEncoderPath, "tokenizer.json").json(), await files.file(paths.textEncoderPath, "tokenizer_config.json").json());
 	const padTokenId = 151643;
 	return ({ prompt, maxLength }) => {
@@ -2714,18 +3108,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,
@@ -2774,15 +3168,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 ? files.directory(options.directory, definition.manifest.directory).path : modelCacheRoot(definition.manifest).path);
+}
+async function prepareImageModelAtPath(definition, options, path) {
+	const model = definition.manifest.model;
+	const root = files.directory(path);
 	await root.create({ recursive: true });
 	const headers = options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0;
-	const total = 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);
@@ -2790,12 +3187,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 files.file(root.path, file.destination).stat();
 		if (stat.type === "file" && stat.size === file.bytes) emitProgress({
 			model,
@@ -2813,7 +3210,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,
@@ -2821,22 +3219,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 ? files.directory(options.directory, definition.manifest.directory).path : modelPathFromOptions(definition, void 0));
+	}))];
 }
 async function deleteImageModel(options = {}) {
-	assertImageModel(options.model ?? flux2Klein4B8BitAbliterated.model);
-	await files.directory(modelRootFromOptions(options.modelRoot)).delete({ recursive: true });
+	const definition = imageModelDefinition(options.model ?? flux2Klein4B8BitAbliterated.model);
+	await files.directory(modelPathFromOptions(definition, options.path)).delete({ recursive: true });
 }
 async function imageMemoryTelemetry() {
 	const value = await bridge().imageMemoryTelemetry?.();
@@ -2974,8 +3376,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;
@@ -3034,16 +3436,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
@@ -3054,7 +3456,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,
@@ -3084,7 +3486,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,
@@ -3115,7 +3520,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);
@@ -3883,6 +4288,59 @@ function stableStringify(value) {
 	return JSON.stringify(value) ?? "undefined";
 }
 
+//#endregion
+//#region src/ai/bonsai-generation.ts
+async function prepareBonsaiGeneration(input) {
+	const state = await verifyBonsaiTextModel(input.model, { path: input.path });
+	if (!state.verified) throw new AIError("model_unavailable", `${input.model.id} is not prepared. Call prepareTextModel() before generation.`);
+	const tokenizer = new Tokenizer_default(await files.file(state.path, "tokenizer.json").json(), await files.file(state.path, "tokenizer_config.json").json());
+	const inputIds = tokenizer.encode(formatMessages(messagesFromInput(input))).ids.map(Number);
+	if (!inputIds.length || inputIds.some((token) => !Number.isInteger(token))) throw new AIError("invalid_message", "Tokenizer returned invalid token ids");
+	return {
+		request: {
+			id: input.id,
+			model: input.model.id,
+			modelPath: state.path,
+			inputIds,
+			endTokenIds: endTokenIds(input.model.id),
+			maxTokens: input.maxTokens,
+			temperature: input.temperature,
+			seed: input.seed
+		},
+		decode(tokenIds) {
+			return tokenIds.length ? tokenizer.decode(tokenIds, { skip_special_tokens: true }) : "";
+		}
+	};
+}
+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/text.ts
 function promptFromInput(options) {
@@ -3893,14 +4351,27 @@ function promptFromInput(options) {
 	if (parts.length === 0) throw new AIError("invalid_message", "Expected prompt or input");
 	return parts.join("\n\n");
 }
-async function isAvailable() {
+async function isAvailable(model, options = {}) {
+	if (model) return (await availability(model, options)).available;
 	try {
 		return await bridge().isAvailable?.() ?? false;
 	} catch {
 		return false;
 	}
 }
-async function availability() {
+async function availability(model, options = {}) {
+	if (model) {
+		const state = await verifyBonsaiTextModel(model, options);
+		if (!state.installed) return {
+			available: false,
+			reason: "not_installed"
+		};
+		if (!state.verified) return {
+			available: false,
+			reason: "invalid_model"
+		};
+		return { available: true };
+	}
 	try {
 		return await bridge().availability?.() ?? {
 			available: false,
@@ -3970,11 +4441,28 @@ async function generate(options) {
 	const output = options.output;
 	const id = generationId();
 	const native = bridge();
-	const toolSubscription = listenForTools(id, options.tools);
+	const toolSubscription = listenForTools(id, "tools" in options ? options.tools : void 0);
 	const abort = () => void native.cancelTextGeneration?.(id);
 	options.signal?.addEventListener("abort", abort, { once: true });
 	try {
 		if (options.signal?.aborted) throw new AIError("generation_canceled", "Generation canceled");
+		if (options.model) {
+			const prepared = await prepareBonsaiGeneration({
+				id,
+				model: options.model,
+				path: options.path,
+				system: options.system,
+				prompt: options.prompt,
+				messages: options.messages,
+				temperature: options.temperature,
+				maxTokens: options.maxTokens,
+				seed: options.seed
+			});
+			if (options.signal?.aborted) throw new AIError("generation_canceled", "Generation canceled");
+			const tokenIds = await native.generateLocalText?.(prepared.request);
+			if (!tokenIds) throw new AIError("unsupported_runtime", "Local text generation is unavailable in this runtime");
+			return prepared.decode(tokenIds);
+		}
 		const value = await native.generate?.(nativeRequest(options, id));
 		if (output) {
 			const result = output["~standard"].validate(value);
@@ -3992,6 +4480,10 @@ async function generate(options) {
 	}
 }
 async function* stream(options) {
+	if (options.model) {
+		yield* streamBonsai(options);
+		return;
+	}
 	const id = generationId();
 	const native = bridge();
 	const updates = [];
@@ -4029,6 +4521,56 @@ async function* stream(options) {
 		toolSubscription?.remove();
 	}
 }
+async function* streamBonsai(options) {
+	const id = generationId();
+	const native = bridge();
+	if (options.signal?.aborted) throw new AIError("generation_canceled", "Generation canceled");
+	const prepared = await prepareBonsaiGeneration({
+		id,
+		model: options.model,
+		path: options.path,
+		system: options.system,
+		prompt: options.prompt,
+		messages: options.messages,
+		temperature: options.temperature,
+		maxTokens: options.maxTokens,
+		seed: options.seed
+	});
+	if (options.signal?.aborted) throw new AIError("generation_canceled", "Generation canceled");
+	const updates = [];
+	let wake;
+	let settled = false;
+	let failure;
+	const updateSubscription = native.addListener?.("localTextGenerationUpdate", (event) => {
+		if (event.id !== id) return;
+		updates.push(event.tokenIds);
+		wake?.();
+		wake = void 0;
+	});
+	const abort = () => void native.cancelTextGeneration?.(id);
+	options.signal?.addEventListener("abort", abort, { once: true });
+	const completion = native.streamLocalText?.(prepared.request).catch((error) => {
+		failure = error;
+		return [];
+	}).finally(() => {
+		settled = true;
+		wake?.();
+		wake = void 0;
+	});
+	try {
+		if (!completion) throw new AIError("unsupported_runtime", "Local text streaming is unavailable in this runtime");
+		while (!settled || updates.length > 0) if (updates.length > 0) yield prepared.decode(updates.shift());
+		else await new Promise((resolve) => {
+			wake = resolve;
+		});
+		await completion;
+		if (failure) throw mapNativeError(failure);
+	} finally {
+		if (!settled) await native.cancelTextGeneration?.(id);
+		options.signal?.removeEventListener("abort", abort);
+		updateSubscription?.remove();
+	}
+}
 
 //#endregion
 //#region src/ai/text-hook.ts
@@ -4099,4 +4641,4 @@ function useTextGeneration() {
 }
 
 //#endregion
-export { AIError, ImageGenerationError, availability, buildImageGenerationRequest, clampOutpaintRect, defaultImageLongSide, deleteImageLoRA, deleteImageModel, flux2Klein4B8BitAbliterated, fluxImageModelPaths, generate, generateImage, generateImages, getImageGenerationJob, imageMemoryTelemetry, imageModelManifest, imageModelManifests, imageSizeForAspectRatio, imageSizeForPreset, initialOutpaintRect, isAvailable, listImageGenerationJobs, listImageLoRAs, listImageModels, normalizeImageSize, prepareImageLoRA, prepareImageModel, rectForSourceScale, roundImageDimension, roundedImageSize, scheduleImageGeneration, shape, stream, unloadImageModel, upscaleImage, useImageComposer, useImageGeneration, useImageModel, useTextGeneration, verifyImageLoRA, verifyImageModel };
+export { AIError, ImageGenerationError, availability, bonsai, bonsaiTextModelCatalog, buildImageGenerationRequest, clampOutpaintRect, defaultImageLongSide, deleteImageLoRA, deleteImageModel, deleteBonsaiTextModel as deleteTextModel, flux2Klein4B8BitAbliterated, fluxImageModelPaths, generate, generateImage, generateImages, getImageGenerationJob, imageMemoryTelemetry, imageModelManifest, imageModelManifests, imageSizeForAspectRatio, imageSizeForPreset, initialOutpaintRect, isAvailable, listImageGenerationJobs, listImageLoRAs, listImageModels, listBonsaiTextModels as listTextModels, normalizeImageSize, prepareImageLoRA, prepareImageModel, prepareBonsaiTextModel as prepareTextModel, rectForSourceScale, roundImageDimension, roundedImageSize, scheduleImageGeneration, shape, stream, ternaryBonsaiImage4B, unloadImageModel, upscaleImage, useImageComposer, useImageGeneration, useImageModel, useTextGeneration, verifyImageLoRA, verifyImageModel, verifyBonsaiTextModel as verifyTextModel };