bleam 0.0.9 → 0.0.11

package/dist/ai.cjs

@@ -11,6 +11,53 @@ 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) {
@@ -50,6 +97,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 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-batch.ts
 function batchImageSeeds(count, seed) {
@@ -247,7 +505,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);
 }
@@ -317,15 +619,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)
 	};
 }
 
@@ -2424,14 +2801,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 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 +2992,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 +3013,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 +3022,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 +3039,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
 	};
@@ -2670,8 +3064,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 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 +3112,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 +3172,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 +3191,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 +3214,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 +3223,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 +3380,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 +3440,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 +3460,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 +3490,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 +3524,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);
@@ -3887,6 +4292,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 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/text.ts
 function promptFromInput(options) {
@@ -3897,14 +4355,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,
@@ -3974,11 +4445,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);
@@ -3996,6 +4484,10 @@ async function generate(options) {
 	}
 }
 async function* stream(options) {
+	if (options.model) {
+		yield* streamBonsai(options);
+		return;
+	}
 	const id = generationId();
 	const native = bridge();
 	const updates = [];
@@ -4033,6 +4525,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
@@ -4106,11 +4648,14 @@ function useTextGeneration() {
 exports.AIError = AIError;
 exports.ImageGenerationError = ImageGenerationError;
 exports.availability = availability;
+exports.bonsai = bonsai;
+exports.bonsaiTextModelCatalog = bonsaiTextModelCatalog;
 exports.buildImageGenerationRequest = buildImageGenerationRequest;
 exports.clampOutpaintRect = clampOutpaintRect;
 exports.defaultImageLongSide = defaultImageLongSide;
 exports.deleteImageLoRA = deleteImageLoRA;
 exports.deleteImageModel = deleteImageModel;
+exports.deleteTextModel = deleteBonsaiTextModel;
 exports.flux2Klein4B8BitAbliterated = flux2Klein4B8BitAbliterated;
 exports.fluxImageModelPaths = fluxImageModelPaths;
 exports.generate = generate;
@@ -4127,15 +4672,18 @@ exports.isAvailable = isAvailable;
 exports.listImageGenerationJobs = listImageGenerationJobs;
 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;
@@ -4143,4 +4691,5 @@ exports.useImageGeneration = useImageGeneration;
 exports.useImageModel = useImageModel;
 exports.useTextGeneration = useTextGeneration;
 exports.verifyImageLoRA = verifyImageLoRA;
-exports.verifyImageModel = verifyImageModel;
+exports.verifyImageModel = verifyImageModel;
+exports.verifyTextModel = verifyBonsaiTextModel;