bleam 0.0.6 → 0.0.7

package/dist/ai.js

@@ -1,6 +1,13 @@
-import { NativeModules } from "react-native";
+import "./native-runtime-C85Nuc4F.js";
+import "./crypto-BB92-Upx.js";
+import { i as files } from "./files-Ds1wT8C2.js";
+import { f as atom, p as useAtom } from "./state-CAwe-Vw1.js";
+import "./schema-Bo5Jvqus.js";
+import { requireNativeModule } from "expo";
+import { useRef, useState } from "react";
+import { Image } from "react-native";
 
-//#region src/ai.ts
+//#region src/ai/errors.ts
 var AIError = class extends Error {
 	constructor(code, message, cause) {
 		super(message);
@@ -9,6 +16,3759 @@ var AIError = class extends Error {
 		this.name = "AIError";
 	}
 };
+var ImageGenerationError = class extends AIError {
+	stage;
+	constructor(stage, message, cause) {
+		super("image_generation_failed", message, cause);
+		this.name = "ImageGenerationError";
+		this.stage = stage;
+	}
+};
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mapNativeError(error) {
+	const code = isRecord(error) && typeof error.code === "string" ? error.code : "";
+	const message = error instanceof Error ? error.message : String(error);
+	if (code === "UNSUPPORTED_OS") return new AIError("unsupported_os", message, error);
+	if (code === "MODEL_UNAVAILABLE") return new AIError("model_unavailable", message, error);
+	if (code === "INVALID_SCHEMA") return new AIError("invalid_schema", message, error);
+	if (code === "INVALID_MESSAGE") return new AIError("invalid_message", message, error);
+	if (code === "INVALID_MODEL") return new AIError("invalid_model", message, error);
+	if (code === "IMAGE_GENERATION_ERROR") return new AIError("image_generation_failed", message, error);
+	if (code === "CONTEXT_WINDOW_EXCEEDED") return new AIError("context_window_exceeded", message, error);
+	if (code === "GENERATION_CANCELED") return new AIError("generation_canceled", message, error);
+	if (code === "CONCURRENT_REQUEST") return new AIError("concurrent_request", message, error);
+	if (code === "GUARDRAIL_VIOLATION") return new AIError("guardrail_violation", message, error);
+	if (code === "UNSUPPORTED_LANGUAGE_OR_LOCALE") return new AIError("unsupported_language_or_locale", message, error);
+	if (code === "RATE_LIMITED") return new AIError("rate_limited", message, error);
+	if (code === "TOOL_ERROR") return new AIError("tool_failed", message, error);
+	return new AIError("generation_failed", message, 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);
+}
+
+//#endregion
+//#region src/ai/image-jobs.ts
+var ImageGenerationQueue = class {
+	jobs = /* @__PURE__ */ new Map();
+	pending = [];
+	running;
+	constructor(executor) {
+		this.executor = executor;
+	}
+	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;
+		});
+		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 }));
+	}
+	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
+			});
+			record.removeSignalListener?.();
+			record.reject(error);
+		}
+		return true;
+	}
+	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 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()
+		});
+		try {
+			const result = await this.executor({
+				...record.options,
+				signal: record.controller.signal,
+				onProgress: (progress) => {
+					record.options.onProgress?.(progress);
+					this.progress(record, progress);
+				}
+			});
+			this.update(record, {
+				status: "completed",
+				result,
+				completedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			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()
+			});
+			record.reject(failure);
+		} finally {
+			record.removeSignalListener?.();
+			this.running = void 0;
+			this.runNext();
+		}
+	}
+	progress(record, progress) {
+		this.update(record, { progress });
+	}
+	update(record, update) {
+		record.snapshot = {
+			...record.snapshot,
+			...update
+		};
+		for (const listener of record.listeners) listener({ ...record.snapshot });
+	}
+};
+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"
+			]
+		}
+	}
+};
+const imageModelManifests = [flux2Klein4B8BitAbliterated];
+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);
+function joinModelPath(root, component) {
+	return `${root.replace(/\/+$/, "")}/${component.replace(/^\/+/, "")}`;
+}
+function fluxImageModelPaths(modelRoot, 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)
+	};
+}
+
+//#endregion
+//#region src/ai/image-schedule.ts
+function imageSigmaSchedule(schedules) {
+	const configured = schedules.filter((schedule) => schedule !== void 0);
+	if (configured.length === 0) return void 0;
+	const first = configured[0];
+	if (first.length === 0 || first.some((sigma, index) => !Number.isFinite(sigma) || sigma <= 0 || sigma > 1 || index > 0 && sigma >= first[index - 1])) throw new AIError("invalid_model", "LoRA sigmaSchedule must contain descending values greater than 0 and at most 1");
+	if (configured.some((schedule) => schedule.length !== first.length || schedule.some((sigma, index) => sigma !== first[index]))) throw new AIError("invalid_model", "Selected LoRAs require conflicting sigma schedules");
+	return [...first];
+}
+
+//#endregion
+//#region src/ai/image-upscale.ts
+function normalizeUpscaleScale(value) {
+	const scale = value ?? 2;
+	if (!Number.isFinite(scale) || scale <= 1 || scale > 4) throw new AIError("invalid_model", "Upscale scale must be greater than 1 and at most 4");
+	return scale;
+}
+
+//#endregion
+//#region src/ai/native.ts
+function bridge() {
+	try {
+		return requireNativeModule("AI");
+	} catch (error) {
+		throw new AIError("unsupported_runtime", "bleam/ai requires the Bleam native runtime", error);
+	}
+}
+
+//#endregion
+//#region src/ai/tokenizers.mjs
+var DictionarySplitter = class {
+	/**
+	* @param dictionary The dictionary of words to use for splitting.
+	*/
+	constructor(dictionary) {
+		this.trie = this._build_trie(dictionary);
+	}
+	/**
+	* Builds a trie from the given dictionary.
+	* @param dictionary The dictionary of words to build the trie from.
+	* @returns The root node of the trie.
+	* @private
+	*/
+	_build_trie(dictionary) {
+		const trie = /* @__PURE__ */ Object.create(null);
+		for (const word of dictionary) {
+			let node = trie;
+			for (let i = 0; i < word.length; ++i) {
+				const char = word[i];
+				node = node[char] ??= /* @__PURE__ */ Object.create(null);
+			}
+			node.end = word;
+		}
+		return trie;
+	}
+	/**
+	* Splits the input text into tokens based on the dictionary.
+	* @param text The input text to split.
+	* @returns An array of tokens.
+	*/
+	split(text) {
+		const result = [];
+		const n = text.length;
+		let start = 0;
+		let i = 0;
+		while (i < n) {
+			let node = this.trie;
+			let match = null;
+			let j = i;
+			while (j < n && (node = node[text[j]])) {
+				if (node.end) match = node.end;
+				++j;
+			}
+			if (match) {
+				if (i > start) result.push(text.slice(start, i));
+				result.push(match);
+				i += match.length;
+				start = i;
+			} else ++i;
+		}
+		if (start < n) result.push(text.slice(start));
+		return result;
+	}
+};
+var DictionarySplitter_default = DictionarySplitter;
+var AddedToken = class {
+	/**
+	* Creates a new instance of AddedToken.
+	* @param config Added token configuration object.
+	*/
+	constructor(config) {
+		this.content = config.content;
+		this.id = config.id;
+		this.single_word = config.single_word ?? false;
+		this.lstrip = config.lstrip ?? false;
+		this.rstrip = config.rstrip ?? false;
+		this.special = config.special ?? false;
+		this.normalized = config.normalized ?? !this.special;
+	}
+};
+var AddedToken_default = AddedToken;
+var BYTES_TO_UNICODE = (() => {
+	const bs = [
+		...Array.from({ length: "~".charCodeAt(0) - "!".charCodeAt(0) + 1 }, (_, i) => i + "!".charCodeAt(0)),
+		...Array.from({ length: "¬".charCodeAt(0) - "¡".charCodeAt(0) + 1 }, (_, i) => i + "¡".charCodeAt(0)),
+		...Array.from({ length: "ÿ".charCodeAt(0) - "®".charCodeAt(0) + 1 }, (_, i) => i + "®".charCodeAt(0))
+	];
+	const cs = bs.slice();
+	let n = 0;
+	for (let b = 0; b < 256; ++b) if (!bs.includes(b)) {
+		bs.push(b);
+		cs.push(256 + n);
+		n += 1;
+	}
+	const ccs = cs.map((n2) => String.fromCharCode(n2));
+	return Object.fromEntries(bs.map((b, i) => [b, ccs[i]]));
+})();
+var reverse_dictionary = (data) => Object.fromEntries(Object.entries(data).map(([key, value]) => [value, key]));
+var UNICODE_TO_BYTES = reverse_dictionary(BYTES_TO_UNICODE);
+var BLOOM_SPLIT_CHARS = ".,!?…。，、।۔،";
+var PROBLEMATIC_REGEX_MAP = /* @__PURE__ */ new Map([
+	["(?i:'s|'t|'re|'ve|'m|'ll|'d)", "(?:'([sS]|[tT]|[rR][eE]|[vV][eE]|[mM]|[lL][lL]|[dD]))"],
+	["(?i:[sdmt]|ll|ve|re)", "(?:[sS]|[dD]|[mM]|[tT]|[lL][lL]|[vV][eE]|[rR][eE])"],
+	["[^\\r\\n\\p{L}\\p{N}]?+", "[^\\r\\n\\p{L}\\p{N}]?"],
+	["[^\\s\\p{L}\\p{N}]++", "[^\\s\\p{L}\\p{N}]+"],
+	["(?>\\p{Nd}{510})", "(?:\\p{Nd}{510})"],
+	["\\p{Nd}{3}+", "(?:\\p{Nd}{3})+"],
+	["\\G", ""],
+	[` ?[^(\\s|[${BLOOM_SPLIT_CHARS}])]+`, ` ?[^\\s${BLOOM_SPLIT_CHARS}]+`]
+]);
+var PUNCTUATION_REGEX = "\\p{P}\\u0021-\\u002F\\u003A-\\u0040\\u005B-\\u0060\\u007B-\\u007E";
+var clean_up_tokenization = (text) => text.replace(/ \./g, ".").replace(/ \?/g, "?").replace(/ \!/g, "!").replace(/ ,/g, ",").replace(/ \' /g, "'").replace(/ n't/g, "n't").replace(/ 'm/g, "'m").replace(/ 's/g, "'s").replace(/ 've/g, "'ve").replace(/ 're/g, "'re");
+var create_pattern = (pattern, invert = true) => {
+	if (pattern.Regex !== void 0) {
+		let regex = pattern.Regex.replace(/\\([#&~])/g, "$1");
+		regex = regex.replace(/\\A/g, "^").replace(/\\z/g, "$").replace(/\\Z/g, "(?=\\r?\\n?$)");
+		for (const [key, value] of PROBLEMATIC_REGEX_MAP) regex = regex.replaceAll(key, value);
+		try {
+			return new RegExp(regex, "gu");
+		} catch (error) {
+			if (!(error instanceof SyntaxError) || !error.message.toLowerCase().includes("invalid property name")) throw error;
+			let changed = false;
+			const fixed = regex.replace(/(\\[pP])\{([^}=]+)\}/g, (_, p, n) => {
+				try {
+					new RegExp(`\\p{${n}}`, "u");
+					return `${p}{${n}}`;
+				} catch {
+					changed = true;
+					return `${p}{Script=${n}}`;
+				}
+			});
+			if (!changed) throw error;
+			try {
+				return new RegExp(fixed, "gu");
+			} catch (e) {
+				throw error;
+			}
+		}
+	} else if (pattern.String !== void 0) {
+		const escaped = escape_reg_exp(pattern.String);
+		return new RegExp(invert ? escaped : `(${escaped})`, "gu");
+	} else {
+		console.warn("Unknown pattern type:", pattern);
+		return null;
+	}
+};
+var escape_reg_exp = (string) => string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var fuse_unk = (arr, tokens_to_ids, unk_token_id) => {
+	const fused = [];
+	let i = 0;
+	while (i < arr.length) {
+		fused.push(arr[i]);
+		if ((tokens_to_ids.get(arr[i]) ?? unk_token_id) !== unk_token_id) {
+			++i;
+			continue;
+		}
+		while (++i < arr.length && (tokens_to_ids.get(arr[i]) ?? unk_token_id) === unk_token_id) if (tokens_to_ids.get(fused.at(-1)) !== unk_token_id) fused[fused.length - 1] += arr[i];
+	}
+	return fused;
+};
+var is_chinese_char = (cp) => cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 131072 && cp <= 173791 || cp >= 173824 && cp <= 177983 || cp >= 177984 && cp <= 178207 || cp >= 178208 && cp <= 183983 || cp >= 63744 && cp <= 64255 || cp >= 194560 && cp <= 195103;
+var is_integral_number = (x) => Number.isInteger(x) || typeof x === "bigint";
+var len = (s) => {
+	let length = 0;
+	for (const c of s) ++length;
+	return length;
+};
+var lowercase_and_remove_accents = (text) => remove_accents(text.toLowerCase());
+var merge_arrays = (...arrs) => Array.prototype.concat.apply([], arrs);
+var object_to_map = (obj) => new Map(Object.entries(obj));
+var regex_split = (text, regex) => {
+	const result = [];
+	let prev = 0;
+	for (const match of text.matchAll(regex)) {
+		const full_match = match[0];
+		if (prev < match.index) result.push(text.slice(prev, match.index));
+		if (full_match.length > 0) result.push(full_match);
+		prev = match.index + full_match.length;
+	}
+	if (prev < text.length) result.push(text.slice(prev));
+	return result;
+};
+var remove_accents = (text) => text.replace(/\p{M}/gu, "");
+var validate_object = (obj, name, required_keys = []) => {
+	if (!obj || Array.isArray(obj) || typeof obj !== "object") return `${name} must be a valid object`;
+	for (const key of required_keys) if (!(key in obj)) return `${name} must contain a "${key}" property`;
+	return null;
+};
+var whitespace_split = (text) => text.match(/\S+/g) || [];
+var Callable = class {
+	/**
+	* Creates a new instance of the Callable class.
+	*/
+	constructor() {
+		const closure = function(...args) {
+			return closure._call(...args);
+		};
+		return Object.setPrototypeOf(closure, new.target.prototype);
+	}
+};
+var Callable_default = Callable;
+var Normalizer = class extends Callable_default {
+	/**
+	* @param config The configuration object for the normalizer.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+	}
+	/**
+	* Alias for {@link Normalizer#normalize}.
+	* @param text The text to normalize.
+	* @returns The normalized text.
+	*/
+	_call(text) {
+		return this.normalize(text);
+	}
+};
+var Normalizer_default = Normalizer;
+var BertNormalizer = class extends Normalizer_default {
+	/**
+	* Adds whitespace around any CJK (Chinese, Japanese, or Korean) character in the input text.
+	*
+	* @param text The input text to tokenize.
+	* @returns The tokenized text with whitespace added around CJK characters.
+	*/
+	tokenize_chinese_chars(text) {
+		const output = [];
+		for (let i = 0; i < text.length; ++i) {
+			const char = text[i];
+			if (is_chinese_char(char.charCodeAt(0))) {
+				output.push(" ");
+				output.push(char);
+				output.push(" ");
+			} else output.push(char);
+		}
+		return output.join("");
+	}
+	/**
+	* Strips accents from the given text.
+	* @param text The text to strip accents from.
+	* @returns The text with accents removed.
+	*/
+	strip_accents(text) {
+		return text.normalize("NFD").replace(/\p{Mn}/gu, "");
+	}
+	/**
+	* Checks whether `char` is a control character.
+	* @param char The character to check.
+	* @returns Whether `char` is a control character.
+	*/
+	is_control(char) {
+		switch (char) {
+			case "	":
+			case "\n":
+			case "\r": return false;
+			default: return /^\p{Cc}|\p{Cf}|\p{Co}|\p{Cs}$/u.test(char);
+		}
+	}
+	/**
+	* Performs invalid character removal and whitespace cleanup on text.
+	* @param text The text to clean.
+	* @returns The cleaned text.
+	*/
+	clean_text(text) {
+		const output = [];
+		for (const char of text) {
+			const cp = char.charCodeAt(0);
+			if (cp === 0 || cp === 65533 || this.is_control(char)) continue;
+			if (/^\s$/.test(char)) output.push(" ");
+			else output.push(char);
+		}
+		return output.join("");
+	}
+	/**
+	* Normalizes the given text based on the configuration.
+	* @param text The text to normalize.
+	* @returns The normalized text.
+	*/
+	normalize(text) {
+		if (this.config.clean_text) text = this.clean_text(text);
+		if (this.config.handle_chinese_chars) text = this.tokenize_chinese_chars(text);
+		if (this.config.lowercase) {
+			text = text.toLowerCase();
+			if (this.config.strip_accents !== false) text = this.strip_accents(text);
+		} else if (this.config.strip_accents) text = this.strip_accents(text);
+		return text;
+	}
+};
+var BertNormalizer_default = BertNormalizer;
+var Precompiled = class extends Normalizer_default {
+	/**
+	* Create a new instance of Precompiled normalizer.
+	* @param config The configuration object.
+	*/
+	constructor(config) {
+		super(config);
+		this.charsmap = config.precompiled_charsmap ?? null;
+	}
+	/**
+	* Normalizes the given text by applying the precompiled charsmap.
+	* @param text The text to normalize.
+	* @returns The normalized text.
+	*/
+	normalize(text) {
+		text = text.replace(/[\u0001-\u0008\u000B\u000E-\u001F\u007F\u008F\u009F]/gm, "");
+		text = text.replace(/[\u0009\u000A\u000C\u000D\u00A0\u1680\u2000-\u200F\u2028\u2029\u202F\u205F\u2581\u3000\uFEFF\uFFFD]/gm, " ");
+		if (text.includes("～")) text = text.split("～").map((part) => part.normalize("NFKC")).join("～");
+		else text = text.normalize("NFKC");
+		return text;
+	}
+};
+var Precompiled_default = Precompiled;
+var Sequence = class extends Normalizer_default {
+	/**
+	* Create a new instance of NormalizerSequence.
+	* @param config The configuration object.
+	*/
+	constructor(config) {
+		super(config);
+		this.normalizers = (config.normalizers ?? []).map((x) => create_normalizer_default(x));
+	}
+	/**
+	* Apply a sequence of Normalizers to the input text.
+	* @param text The text to normalize.
+	* @returns The normalized text.
+	*/
+	normalize(text) {
+		return this.normalizers.reduce((t, normalizer) => {
+			return normalizer ? normalizer.normalize(t) : t;
+		}, text);
+	}
+};
+var Sequence_default = Sequence;
+var Replace = class extends Normalizer_default {
+	/**
+	* Normalize the input text by replacing the pattern with the content.
+	* @param text The input text to be normalized.
+	* @returns The normalized text after replacing the pattern with the content.
+	*/
+	normalize(text) {
+		const pattern = create_pattern(this.config.pattern ?? {});
+		return pattern === null ? text : text.replaceAll(pattern, this.config.content ?? "");
+	}
+};
+var Replace_default = Replace;
+var UnicodeNormalizer = class extends Normalizer_default {
+	constructor() {
+		super(...arguments);
+		/**
+		* The Unicode normalization form to apply.
+		* Should be one of: 'NFC', 'NFD', 'NFKC', or 'NFKD'.
+		*/
+		this.form = "NFC";
+	}
+	/**
+	* Normalize the input text by applying Unicode normalization.
+	* @param text The input text to be normalized.
+	* @returns The normalized text.
+	*/
+	normalize(text) {
+		text = text.normalize(this.form);
+		return text;
+	}
+};
+var UnicodeNormalizer_default = UnicodeNormalizer;
+var NFC = class extends UnicodeNormalizer_default {
+	constructor() {
+		super(...arguments);
+		this.form = "NFC";
+	}
+};
+var NFC_default = NFC;
+var NFD = class extends UnicodeNormalizer_default {
+	constructor() {
+		super(...arguments);
+		this.form = "NFD";
+	}
+};
+var NFD_default = NFD;
+var NFKC = class extends UnicodeNormalizer_default {
+	constructor() {
+		super(...arguments);
+		this.form = "NFKC";
+	}
+};
+var NFKC_default = NFKC;
+var NFKD = class extends UnicodeNormalizer_default {
+	constructor() {
+		super(...arguments);
+		this.form = "NFKD";
+	}
+};
+var NFKD_default = NFKD;
+var Strip = class extends Normalizer_default {
+	/**
+	* Strip leading and/or trailing whitespace from the input text.
+	* @param text The input text.
+	* @returns The normalized text.
+	*/
+	normalize(text) {
+		if (this.config.strip_left && this.config.strip_right) text = text.trim();
+		else {
+			if (this.config.strip_left) text = text.trimStart();
+			if (this.config.strip_right) text = text.trimEnd();
+		}
+		return text;
+	}
+};
+var Strip_default = Strip;
+var StripAccents = class extends Normalizer_default {
+	/**
+	* Remove all accents from the text.
+	* @param text The input text.
+	* @returns The normalized text without accents.
+	*/
+	normalize(text) {
+		return remove_accents(text);
+	}
+};
+var StripAccents_default = StripAccents;
+var Lowercase = class extends Normalizer_default {
+	/**
+	* Lowercases the input string.
+	* @param {string} text The text to normalize.
+	* @returns {string} The normalized text.
+	*/
+	normalize(text) {
+		return text.toLowerCase();
+	}
+};
+var Lowercase_default = Lowercase;
+var Prepend = class extends Normalizer_default {
+	/**
+	* Prepends the input string.
+	* @param text The text to normalize.
+	* @returns The normalized text.
+	*/
+	normalize(text) {
+		text = this.config.prepend + text;
+		return text;
+	}
+};
+var Prepend_default = Prepend;
+function create_normalizer(config) {
+	if (config === null) return null;
+	switch (config.type) {
+		case "BertNormalizer": return new BertNormalizer_default(config);
+		case "Precompiled": return new Precompiled_default(config);
+		case "Sequence": return new Sequence_default(config);
+		case "Replace": return new Replace_default(config);
+		case "NFC": return new NFC_default(config);
+		case "NFD": return new NFD_default(config);
+		case "NFKC": return new NFKC_default(config);
+		case "NFKD": return new NFKD_default(config);
+		case "Strip": return new Strip_default(config);
+		case "StripAccents": return new StripAccents_default(config);
+		case "Lowercase": return new Lowercase_default(config);
+		case "Prepend": return new Prepend_default(config);
+		default: throw new Error(`Unknown Normalizer type: ${config.type}`);
+	}
+}
+var create_normalizer_default = create_normalizer;
+var PreTokenizer = class extends Callable_default {
+	/**
+	* Tokenizes the given text into pre-tokens.
+	* @param text The text or array of texts to pre-tokenize.
+	* @param options Additional options for the pre-tokenization logic.
+	* @returns An array of pre-tokens.
+	*/
+	pre_tokenize(text, options) {
+		return (Array.isArray(text) ? text.map((x) => this.pre_tokenize_text(x, options)) : this.pre_tokenize_text(text, options)).flat();
+	}
+	/**
+	* Alias for {@link PreTokenizer#pre_tokenize}.
+	* @param text The text or array of texts to pre-tokenize.
+	* @param options Additional options for the pre-tokenization logic.
+	* @returns An array of pre-tokens.
+	*/
+	_call(text, options) {
+		return this.pre_tokenize(text, options);
+	}
+};
+var PreTokenizer_default = PreTokenizer;
+var ByteLevel = class extends PreTokenizer_default {
+	/**
+	* Creates a new instance of the `ByteLevelPreTokenizer` class.
+	* @param config The configuration object.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+		this.add_prefix_space = this.config.add_prefix_space ?? false;
+		this.trim_offsets = this.config.trim_offsets ?? false;
+		this.use_regex = this.config.use_regex ?? true;
+		this.pattern = /'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+/gu;
+		this.byte_encoder = BYTES_TO_UNICODE;
+		this.text_encoder = new TextEncoder();
+	}
+	/**
+	* Tokenizes a single piece of text using byte-level tokenization.
+	* @param text The text to tokenize.
+	* @param options Additional options for the pre-tokenization logic.
+	* @returns An array of tokens.
+	*/
+	pre_tokenize_text(text, options) {
+		if (this.add_prefix_space && !text.startsWith(" ")) text = " " + text;
+		return (this.use_regex ? text.match(this.pattern) || [] : [text]).map((token) => Array.from(this.text_encoder.encode(token), (byte) => this.byte_encoder[byte]).join(""));
+	}
+};
+var ByteLevel_default = ByteLevel;
+var Whitespace = class extends PreTokenizer_default {
+	/**
+	* Pre-tokenizes the input text by splitting it on word boundaries.
+	* @param text The text to be pre-tokenized.
+	* @param options Additional options for the pre-tokenization logic.
+	* @returns An array of tokens produced by splitting the input text on whitespace.
+	*/
+	pre_tokenize_text(text, options) {
+		return text.match(/\w+|[^\w\s]+/g) || [];
+	}
+};
+var Whitespace_default = Whitespace;
+var Metaspace = class extends PreTokenizer_default {
+	/**
+	* @param config The configuration object for the MetaspacePreTokenizer.
+	*/
+	constructor(config) {
+		super();
+		this.replacement = config.replacement ?? "▁";
+		this.str_rep = config.str_rep || this.replacement;
+		this.prepend_scheme = config.prepend_scheme ?? "always";
+	}
+	/**
+	* This method takes a string, replaces spaces with the replacement character,
+	* adds a prefix space if requested, and returns a new list of tokens.
+	* @param text The text to pre-tokenize.
+	* @param options The options for the pre-tokenization.
+	* @returns A new list of pre-tokenized tokens.
+	*/
+	pre_tokenize_text(text, options) {
+		const { section_index = void 0 } = options ?? {};
+		let normalized = text.replaceAll(" ", this.str_rep);
+		if (!normalized.startsWith(this.replacement) && (this.prepend_scheme === "always" || this.prepend_scheme === "first" && section_index === 0)) normalized = this.str_rep + normalized;
+		return [normalized];
+	}
+};
+var Metaspace_default = Metaspace;
+var Split = class extends PreTokenizer_default {
+	/**
+	* @param config The configuration options for the pre-tokenizer.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+		this.pattern = create_pattern(this.config.pattern ?? {}, this.config.invert ?? true);
+	}
+	/**
+	* Tokenizes text by splitting it using the given pattern.
+	* @param text The text to tokenize.
+	* @returns An array of tokens.
+	*/
+	pre_tokenize_text(text) {
+		if (this.pattern === null) return [];
+		if (this.config.invert) return text.match(this.pattern) || [];
+		else if (this.config.behavior?.toLowerCase() === "removed") return text.split(this.pattern).filter((x) => x);
+		else return regex_split(text, this.pattern);
+	}
+};
+var Split_default = Split;
+var Punctuation = class extends PreTokenizer_default {
+	/**
+	* @param config The configuration options for the pre-tokenizer.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+		this.pattern = new RegExp(`[^${PUNCTUATION_REGEX}]+|[${PUNCTUATION_REGEX}]+`, "gu");
+	}
+	/**
+	* Tokenizes text by splitting it using the given pattern.
+	* @param text The text to tokenize.
+	* @returns An array of tokens.
+	*/
+	pre_tokenize_text(text) {
+		return text.match(this.pattern) || [];
+	}
+};
+var Punctuation_default = Punctuation;
+var Digits = class extends PreTokenizer_default {
+	/**
+	* @param config The configuration options for the pre-tokenizer.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+		const digit_pattern = `[^\\d]+|\\d${this.config.individual_digits ? "" : "+"}`;
+		this.pattern = new RegExp(digit_pattern, "gu");
+	}
+	/**
+	* Tokenizes text by splitting it using the given pattern.
+	* @param text The text to tokenize.
+	* @returns An array of tokens.
+	*/
+	pre_tokenize_text(text) {
+		return text.match(this.pattern) || [];
+	}
+};
+var Digits_default = Digits;
+var BertPreTokenizer = class extends PreTokenizer_default {
+	/**
+	* A PreTokenizer that splits text into wordpieces using a basic tokenization scheme
+	* similar to that used in the original implementation of BERT.
+	*/
+	constructor() {
+		super();
+		this.pattern = new RegExp(`[^\\s${PUNCTUATION_REGEX}]+|[${PUNCTUATION_REGEX}]`, "gu");
+	}
+	/**
+	* Tokenizes a single text using the BERT pre-tokenization scheme.
+	*
+	* @param text The text to tokenize.
+	* @param options Additional options for the pre-tokenization logic.
+	* @returns An array of tokens.
+	*/
+	pre_tokenize_text(text, options) {
+		return text.trim().match(this.pattern) || [];
+	}
+};
+var BertPreTokenizer_default = BertPreTokenizer;
+var Replace2 = class extends PreTokenizer_default {
+	/**
+	* @param config The configuration options for the pre-tokenizer.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+		this.pattern = create_pattern(this.config.pattern ?? {});
+		this.content = this.config.content ?? "";
+	}
+	/**
+	* Pre-tokenizes the input text by replacing certain characters.
+	* @param text The text to be pre-tokenized.
+	* @returns An array of tokens produced by replacing certain characters.
+	*/
+	pre_tokenize_text(text) {
+		if (this.pattern === null) return [text];
+		return [text.replaceAll(this.pattern, this.config.content ?? "")];
+	}
+};
+var Replace_default2 = Replace2;
+var Sequence2 = class extends PreTokenizer_default {
+	/**
+	* Creates an instance of PreTokenizerSequence.
+	* @param config The configuration object for the pre-tokenizer sequence.
+	*/
+	constructor(config) {
+		super();
+		this.tokenizers = (config.pretokenizers ?? []).map((x) => create_pre_tokenizer_default(x));
+	}
+	/**
+	* Applies each pre-tokenizer in the sequence to the input text in turn.
+	* @param text The text to pre-tokenize.
+	* @param options Additional options for the pre-tokenization logic.
+	* @returns The pre-tokenized text.
+	*/
+	pre_tokenize_text(text, options) {
+		return this.tokenizers.reduce((pre_tokenized_text, tokenizer) => {
+			return tokenizer ? tokenizer.pre_tokenize(pre_tokenized_text, options) : pre_tokenized_text;
+		}, [text]);
+	}
+};
+var Sequence_default2 = Sequence2;
+var WhitespaceSplit = class extends PreTokenizer_default {
+	/**
+	* Pre-tokenizes the input text by splitting it on whitespace characters.
+	* @param text The text to be pre-tokenized.
+	* @returns An array of tokens produced by splitting the input text on whitespace.
+	*/
+	pre_tokenize_text(text) {
+		return whitespace_split(text);
+	}
+};
+var WhitespaceSplit_default = WhitespaceSplit;
+var FixedLength = class extends PreTokenizer_default {
+	/**
+	* @param config The configuration options for the pre-tokenizer.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+		this._length = config.length;
+	}
+	/**
+	* Pre-tokenizes the input text by splitting it into fixed-length tokens.
+	* @param text The text to be pre-tokenized.
+	* @returns An array of tokens produced by splitting the input text into fixed-length tokens.
+	*/
+	pre_tokenize_text(text) {
+		const tokens = [];
+		for (let i = 0; i < text.length; i += this._length) tokens.push(text.slice(i, i + this._length));
+		return tokens;
+	}
+};
+var FixedLength_default = FixedLength;
+function create_pre_tokenizer(config) {
+	if (config === null) return null;
+	switch (config.type) {
+		case "BertPreTokenizer": return new BertPreTokenizer_default();
+		case "Sequence": return new Sequence_default2(config);
+		case "Whitespace": return new Whitespace_default();
+		case "WhitespaceSplit": return new WhitespaceSplit_default();
+		case "Metaspace": return new Metaspace_default(config);
+		case "ByteLevel": return new ByteLevel_default(config);
+		case "Split": return new Split_default(config);
+		case "Punctuation": return new Punctuation_default(config);
+		case "Digits": return new Digits_default(config);
+		case "Replace": return new Replace_default2(config);
+		case "FixedLength": return new FixedLength_default(config);
+		default: throw new Error(`Unknown PreTokenizer type: ${config.type}`);
+	}
+}
+var create_pre_tokenizer_default = create_pre_tokenizer;
+var TokenizerModel = class extends Callable_default {
+	/**
+	* Creates a new instance of TokenizerModel.
+	* @param config The configuration object for the TokenizerModel.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+		this.vocab = [];
+		this.tokens_to_ids = /* @__PURE__ */ new Map();
+		this.unk_token_id = void 0;
+		this.unk_token = void 0;
+		this.end_of_word_suffix = void 0;
+		this.fuse_unk = this.config.fuse_unk ?? false;
+	}
+	/**
+	* Internal function to call the TokenizerModel instance.
+	* @param tokens The tokens to encode.
+	* @returns The encoded tokens.
+	*/
+	_call(tokens) {
+		let result = this.encode(tokens);
+		if (this.fuse_unk) result = fuse_unk(result, this.tokens_to_ids, this.unk_token_id);
+		return result;
+	}
+};
+var TokenizerModel_default = TokenizerModel;
+var WordPieceTokenizer = class extends TokenizerModel_default {
+	/**
+	* @param config The configuration object.
+	*/
+	constructor(config) {
+		super(config);
+		/** The maximum number of characters per word. */
+		this.max_input_chars_per_word = 100;
+		this.tokens_to_ids = object_to_map(config.vocab);
+		this.unk_token_id = this.tokens_to_ids.get(config.unk_token);
+		this.unk_token = config.unk_token;
+		this.max_input_chars_per_word = config.max_input_chars_per_word ?? 100;
+		this.vocab = new Array(this.tokens_to_ids.size);
+		for (const [key, value] of this.tokens_to_ids) this.vocab[value] = key;
+	}
+	/**
+	* Encodes an array of tokens using WordPiece encoding.
+	* @param tokens The tokens to encode.
+	* @returns An array of encoded tokens.
+	*/
+	encode(tokens) {
+		const output_tokens = [];
+		for (const token of tokens) {
+			const chars = [...token];
+			if (chars.length > this.max_input_chars_per_word) {
+				output_tokens.push(this.unk_token);
+				continue;
+			}
+			let is_unknown = false;
+			let start = 0;
+			const sub_tokens = [];
+			while (start < chars.length) {
+				let end = chars.length;
+				let current_substring = null;
+				while (start < end) {
+					let substr = chars.slice(start, end).join("");
+					if (start > 0) substr = this.config.continuing_subword_prefix + substr;
+					if (this.tokens_to_ids.has(substr)) {
+						current_substring = substr;
+						break;
+					}
+					--end;
+				}
+				if (current_substring === null) {
+					is_unknown = true;
+					break;
+				}
+				sub_tokens.push(current_substring);
+				start = end;
+			}
+			if (is_unknown) output_tokens.push(this.unk_token);
+			else output_tokens.push(...sub_tokens);
+		}
+		return output_tokens;
+	}
+};
+var WordPiece_default = WordPieceTokenizer;
+var CharTrieNode = class _CharTrieNode {
+	/**
+	* Create a new CharTrieNode.
+	* @param is_leaf Whether the node is a leaf node or not.
+	* @param children A map containing the node's children, where the key is a character and the value is a `CharTrieNode`.
+	*/
+	constructor(is_leaf, children) {
+		this.is_leaf = is_leaf;
+		this.children = children;
+	}
+	/**
+	* Returns a new `CharTrieNode` instance with default values.
+	* @returns A new `CharTrieNode` instance with `is_leaf` set to `false` and an empty `children` map.
+	*/
+	static default() {
+		return new _CharTrieNode(false, /* @__PURE__ */ new Map());
+	}
+};
+var CharTrie = class {
+	constructor() {
+		this.root = CharTrieNode.default();
+	}
+	/**
+	* Adds one or more `texts` to the trie.
+	* @param texts The strings to add to the trie.
+	*/
+	extend(texts) {
+		for (const text of texts) this.push(text);
+	}
+	/**
+	* Adds text to the trie.
+	* @param text The string to add to the trie.
+	*/
+	push(text) {
+		let node = this.root;
+		for (const ch of text) {
+			let child = node.children.get(ch);
+			if (child === void 0) {
+				child = CharTrieNode.default();
+				node.children.set(ch, child);
+			}
+			node = child;
+		}
+		node.is_leaf = true;
+	}
+	/**
+	* Searches the trie for all strings with a common prefix of `text`.
+	* @param text The common prefix to search for.
+	* @yields Each string in the trie that has `text` as a prefix.
+	*/
+	*common_prefix_search(text) {
+		let node = this.root;
+		if (node === void 0) return;
+		let prefix = "";
+		for (const ch of text) {
+			prefix += ch;
+			node = node.children.get(ch);
+			if (node === void 0) return;
+			if (node.is_leaf) yield prefix;
+		}
+	}
+};
+var CharTrie_default = CharTrie;
+var TokenLatticeNode = class _TokenLatticeNode {
+	/**
+	* Represents a node in a token lattice for a given sentence.
+	* @param token_id The ID of the token associated with this node.
+	* @param node_id The ID of this node.
+	* @param pos The starting position of the token in the sentence.
+	* @param length The length of the token.
+	* @param score The score associated with the token.
+	*/
+	constructor(token_id, node_id, pos, length, score) {
+		this.token_id = token_id;
+		this.node_id = node_id;
+		this.pos = pos;
+		this.length = length;
+		this.score = score;
+		this.prev = null;
+		this.backtrace_score = 0;
+	}
+	/**
+	* Returns a clone of this node.
+	* @returns A clone of this node.
+	*/
+	clone() {
+		const n = new _TokenLatticeNode(this.token_id, this.node_id, this.pos, this.length, this.score);
+		n.prev = this.prev;
+		n.backtrace_score = this.backtrace_score;
+		return n;
+	}
+};
+var TokenLattice = class {
+	/**
+	* Creates a new TokenLattice instance.
+	*
+	* @param sentence The input sentence to be tokenized.
+	* @param bos_token_id The beginning-of-sequence token ID.
+	* @param eos_token_id The end-of-sequence token ID.
+	*/
+	constructor(sentence, bos_token_id, eos_token_id) {
+		this.chars = Array.from(sentence);
+		this.len = this.chars.length;
+		this.bos_token_id = bos_token_id;
+		this.eos_token_id = eos_token_id;
+		this.nodes = [];
+		this.begin_nodes = Array.from({ length: this.len + 1 }, () => []);
+		this.end_nodes = Array.from({ length: this.len + 1 }, () => []);
+		const bos = new TokenLatticeNode(this.bos_token_id ?? 0, 0, 0, 0, 0);
+		const eos = new TokenLatticeNode(this.eos_token_id ?? 0, 1, this.len, 0, 0);
+		this.nodes.push(bos.clone());
+		this.nodes.push(eos.clone());
+		this.begin_nodes[this.len].push(eos);
+		this.end_nodes[0].push(bos);
+	}
+	/**
+	* Inserts a new token node into the token lattice.
+	*
+	* @param pos The starting position of the token.
+	* @param length The length of the token.
+	* @param score The score of the token.
+	* @param token_id The token ID of the token.
+	*/
+	insert(pos, length, score, token_id) {
+		const node_id = this.nodes.length;
+		const node = new TokenLatticeNode(token_id, node_id, pos, length, score);
+		this.begin_nodes[pos].push(node);
+		this.end_nodes[pos + length].push(node);
+		this.nodes.push(node);
+	}
+	/**
+	* Implements the Viterbi algorithm to compute the most likely sequence of tokens.
+	*
+	* @returns The most likely sequence of tokens.
+	*/
+	viterbi() {
+		const len2 = this.len;
+		let pos = 0;
+		while (pos <= len2) {
+			if (this.begin_nodes[pos].length == 0) return [];
+			for (let rnode of this.begin_nodes[pos]) {
+				rnode.prev = null;
+				let best_score = 0;
+				let best_node = null;
+				for (let lnode of this.end_nodes[pos]) {
+					const score = lnode.backtrace_score + rnode.score;
+					if (best_node === null || score > best_score) {
+						best_node = lnode.clone();
+						best_score = score;
+					}
+				}
+				if (best_node !== null) {
+					rnode.prev = best_node;
+					rnode.backtrace_score = best_score;
+				} else return [];
+			}
+			++pos;
+		}
+		const results = [];
+		const prev = this.begin_nodes[len2][0].prev;
+		if (prev === null) return [];
+		let node = prev.clone();
+		while (node.prev !== null) {
+			results.push(node.clone());
+			node = node.clone().prev.clone();
+		}
+		results.reverse();
+		return results;
+	}
+	/**
+	* Get the text piece for a given node.
+	* @param node The node to get the piece for.
+	* @returns The array of nodes representing the most likely sequence of tokens.
+	*/
+	piece(node) {
+		return this.chars.slice(node.pos, node.pos + node.length).join("");
+	}
+	/**
+	* @returns The most likely sequence of tokens.
+	*/
+	tokens() {
+		return this.viterbi().map((x) => this.piece(x));
+	}
+	/**
+	* @returns The most likely sequence of token ids.
+	*/
+	token_ids() {
+		return this.viterbi().map((x) => x.token_id);
+	}
+};
+var TokenLattice_default = TokenLattice;
+function min(arr) {
+	if (arr.length === 0) throw new Error("Array must not be empty");
+	let min_value = arr[0];
+	let index_of_min = 0;
+	for (let i = 1; i < arr.length; ++i) if (arr[i] < min_value) {
+		min_value = arr[i];
+		index_of_min = i;
+	}
+	return [min_value, index_of_min];
+}
+var Unigram = class extends TokenizerModel_default {
+	/**
+	* Create a new Unigram tokenizer model.
+	* @param config The configuration object for the Unigram model.
+	* @param eos_token
+	*/
+	constructor(config, eos_token) {
+		super(config);
+		const vocab_size = config.vocab.length;
+		this.vocab = new Array(vocab_size);
+		this.scores = new Array(vocab_size);
+		for (let i = 0; i < vocab_size; ++i) [this.vocab[i], this.scores[i]] = config.vocab[i];
+		this.unk_token_id = config.unk_id;
+		this.unk_token = this.vocab[config.unk_id];
+		this.tokens_to_ids = new Map(this.vocab.map((x, i) => [x, i]));
+		this.bos_token = " ";
+		this.bos_token_id = this.tokens_to_ids.get(this.bos_token);
+		this.eos_token = eos_token;
+		this.eos_token_id = this.tokens_to_ids.get(this.eos_token);
+		this.unk_token = this.vocab[this.unk_token_id];
+		this.min_score = min(this.scores)[0];
+		this.unk_score = this.min_score - 10;
+		this.scores[this.unk_token_id] = this.unk_score;
+		this.trie = new CharTrie_default();
+		this.trie.extend(this.vocab);
+		this.fuse_unk = true;
+	}
+	/**
+	* Populates lattice nodes.
+	* @param lattice The token lattice to populate with nodes.
+	*/
+	populate_nodes(lattice) {
+		const chars = lattice.chars;
+		const mblen = 1;
+		let begin_pos = 0;
+		while (begin_pos < chars.length) {
+			let has_single_node = false;
+			const tokens = [];
+			const sliced = chars.slice(begin_pos).join("");
+			const prefixed_tokens = this.trie.common_prefix_search(sliced);
+			for (const token of prefixed_tokens) {
+				tokens.push(token);
+				const token_id = this.tokens_to_ids.get(token);
+				const token_score = this.scores[token_id];
+				const n = len(token);
+				lattice.insert(begin_pos, n, token_score, token_id);
+				if (!has_single_node && n === mblen) has_single_node = true;
+			}
+			if (!has_single_node) lattice.insert(begin_pos, mblen, this.unk_score, this.unk_token_id);
+			begin_pos += mblen;
+		}
+	}
+	/**
+	* Encodes an array of tokens into an array of subtokens using the unigram model.
+	*
+	* @param normalized The normalized string.
+	* @returns An array of subtokens obtained by encoding the input tokens using the unigram model.
+	*/
+	tokenize(normalized) {
+		const lattice = new TokenLattice_default(normalized, this.bos_token_id, this.eos_token_id);
+		this.populate_nodes(lattice);
+		return lattice.tokens();
+	}
+	/**
+	* Encodes an array of tokens using Unigram encoding.
+	* @param tokens The tokens to encode.
+	* @returns An array of encoded tokens.
+	*/
+	encode(tokens) {
+		const to_return = [];
+		for (const token of tokens) {
+			const tokenized = this.tokenize(token);
+			to_return.push(...tokenized);
+		}
+		return to_return;
+	}
+};
+var Unigram_default = Unigram;
+var PriorityQueue = class {
+	/**
+	* Create a new PriorityQueue.
+	* @param comparator Comparator function to determine priority. Defaults to a MaxHeap.
+	* @param max_size Maximum size of the queue. Defaults to Infinity.
+	*/
+	constructor(comparator = (a, b) => a > b, max_size = Infinity) {
+		this._heap = [];
+		this._comparator = comparator;
+		this._max_size = max_size;
+	}
+	/**
+	* The size of the queue
+	*/
+	get size() {
+		return this._heap.length;
+	}
+	/**
+	* Check if the queue is empty.
+	* @returns `true` if the queue is empty, `false` otherwise.
+	*/
+	is_empty() {
+		return this.size === 0;
+	}
+	/**
+	* Return the element with the highest priority in the queue.
+	* @returns The highest priority element in the queue.
+	*/
+	peek() {
+		return this._heap[0];
+	}
+	/**
+	* Add one or more elements to the queue.
+	* @param values The values to push into the queue.
+	* @returns The new size of the queue.
+	*/
+	push(...values) {
+		return this.extend(values);
+	}
+	/**
+	* Add multiple elements to the queue.
+	* @param values The values to push into the queue.
+	* @returns The new size of the queue.
+	*/
+	extend(values) {
+		for (const value of values) if (this.size < this._max_size) {
+			this._heap.push(value);
+			this._sift_up();
+		} else {
+			const smallest = this._smallest();
+			if (this._comparator(value, this._heap[smallest])) {
+				this._heap[smallest] = value;
+				this._sift_up_from(smallest);
+			}
+		}
+		return this.size;
+	}
+	/**
+	* Remove and return the element with the highest priority in the queue.
+	* @returns The element with the highest priority in the queue.
+	*/
+	pop() {
+		const popped_value = this.peek();
+		const bottom = this.size - 1;
+		if (bottom > 0) this._swap(0, bottom);
+		this._heap.pop();
+		this._sift_down();
+		return popped_value;
+	}
+	/**
+	* Replace the element with the highest priority in the queue with a new value.
+	* @param value The new value.
+	* @returns The replaced value.
+	*/
+	replace(value) {
+		const replaced_value = this.peek();
+		this._heap[0] = value;
+		this._sift_down();
+		return replaced_value;
+	}
+	/**
+	* Compute the index for the parent of the node at index `i`.
+	* @param i The index of the node to get the parent of.
+	* @returns The index of the parent node.
+	* @private
+	*/
+	_parent(i) {
+		return (i + 1 >>> 1) - 1;
+	}
+	/**
+	* Compute the index for the left child of the node at index `i`.
+	* @param i The index of the node to get the left child of.
+	* @returns The index of the left child.
+	* @private
+	*/
+	_left(i) {
+		return (i << 1) + 1;
+	}
+	/**
+	* Compute the index for the right child of the node at index `i`.
+	* @param i The index of the node to get the right child of.
+	* @returns The index of the right child.
+	* @private
+	*/
+	_right(i) {
+		return i + 1 << 1;
+	}
+	/**
+	* Check if the element at index `i` is greater than the element at index `j`.
+	* @param i The index of the first element to compare.
+	* @param j The index of the second element to compare.
+	* @returns `true` if the element at index `i` is greater than the element at index `j`, `false` otherwise.
+	* @private
+	*/
+	_greater(i, j) {
+		return this._comparator(this._heap[i], this._heap[j]);
+	}
+	/**
+	* Swap the elements at indices `i` and `j`.
+	* @param i The index of the first element to swap.
+	* @param j The index of the second element to swap.
+	* @private
+	*/
+	_swap(i, j) {
+		const temp = this._heap[i];
+		this._heap[i] = this._heap[j];
+		this._heap[j] = temp;
+	}
+	/**
+	* Maintain the heap property by updating positions in the heap,
+	* starting at the last element and moving up the heap.
+	* @private
+	*/
+	_sift_up() {
+		this._sift_up_from(this.size - 1);
+	}
+	/**
+	* Helper function to sift up from a given node.
+	* @param node The index of the node to start sifting up from.
+	*/
+	_sift_up_from(node) {
+		while (node > 0 && this._greater(node, this._parent(node))) {
+			this._swap(node, this._parent(node));
+			node = this._parent(node);
+		}
+	}
+	/**
+	* Maintain the heap property by updating positions in the heap,
+	* starting at the first element and moving down the heap.
+	* @private
+	*/
+	_sift_down() {
+		let node = 0;
+		while (this._left(node) < this.size && this._greater(this._left(node), node) || this._right(node) < this.size && this._greater(this._right(node), node)) {
+			const max_child = this._right(node) < this.size && this._greater(this._right(node), this._left(node)) ? this._right(node) : this._left(node);
+			this._swap(node, max_child);
+			node = max_child;
+		}
+	}
+	/**
+	* Get the index of the smallest element in the heap. Since we use an array-based heap,
+	* the index can be computed without needing to traverse the heap.
+	* @private
+	*/
+	_smallest() {
+		return 2 ** Math.floor(Math.log2(this.size)) - 1;
+	}
+};
+var PriorityQueue_default = PriorityQueue;
+var LRUCache = class {
+	/**
+	* Creates an LRUCache instance.
+	* @param capacity The maximum number of items the cache can hold.
+	*/
+	constructor(capacity) {
+		this.capacity = capacity;
+		this.cache = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Retrieves the value associated with the given key and marks the key as recently used.
+	* @param key The key to retrieve.
+	* @returns The value associated with the key, or undefined if the key does not exist.
+	*/
+	get(key) {
+		if (!this.cache.has(key)) return void 0;
+		const value = this.cache.get(key);
+		this.cache.delete(key);
+		this.cache.set(key, value);
+		return value;
+	}
+	/**
+	* Inserts or updates the key-value pair in the cache.
+	* If the key already exists, it is updated and marked as recently used.
+	* If the cache exceeds its capacity, the least recently used item is evicted.
+	* @param key The key to add or update.
+	* @param value The value to associate with the key.
+	*/
+	put(key, value) {
+		if (this.cache.has(key)) this.cache.delete(key);
+		this.cache.set(key, value);
+		if (this.cache.size > this.capacity) this.cache.delete(this.cache.keys().next().value);
+	}
+	/**
+	* Clears the cache.
+	*/
+	clear() {
+		this.cache.clear();
+	}
+};
+var LRUCache_default = LRUCache;
+var BPE = class extends TokenizerModel_default {
+	/**
+	* Create a BPE instance.
+	* @param config The configuration object for BPE.
+	*/
+	constructor(config) {
+		super(config);
+		this.tokens_to_ids = object_to_map(config.vocab);
+		this.unk_token_id = this.tokens_to_ids.get(config.unk_token);
+		this.unk_token = config.unk_token;
+		this.vocab = new Array(this.tokens_to_ids.size);
+		for (const [key, value] of this.tokens_to_ids) this.vocab[value] = key;
+		this.merges = Array.isArray(config.merges[0]) ? config.merges : config.merges.map((x) => x.split(" ", 2));
+		this.bpe_ranks = new Map(this.merges.map((x, i) => [JSON.stringify(x), i]));
+		this.end_of_word_suffix = config.end_of_word_suffix;
+		this.continuing_subword_suffix = config.continuing_subword_suffix ?? null;
+		this.byte_fallback = this.config.byte_fallback ?? false;
+		if (this.byte_fallback) this.text_encoder = new TextEncoder();
+		this.ignore_merges = this.config.ignore_merges ?? false;
+		this.max_length_to_cache = 256;
+		this.cache_capacity = 1e4;
+		this.cache = new LRUCache_default(this.cache_capacity);
+	}
+	/**
+	* Clears the cache.
+	*/
+	clear_cache() {
+		this.cache.clear();
+	}
+	/**
+	* Apply Byte-Pair-Encoding (BPE) to a given token. Efficient heap-based priority
+	* queue implementation adapted from https://github.com/belladoreai/llama-tokenizer-js.
+	* @param token The token to encode.
+	* @returns The BPE encoded tokens.
+	*/
+	bpe(token) {
+		if (token.length === 0) return [];
+		const cached = this.cache.get(token);
+		if (cached !== void 0) return cached;
+		const word = Array.from(token);
+		if (this.end_of_word_suffix) word[word.length - 1] += this.end_of_word_suffix;
+		let result = [];
+		if (word.length > 1) {
+			const queue = new PriorityQueue_default((a, b) => a.score < b.score);
+			let starting_node = {
+				token: word[0],
+				bias: 0,
+				prev: null,
+				next: null
+			};
+			let previous_node = starting_node;
+			for (let i = 1; i < word.length; ++i) {
+				const current_node = {
+					bias: i / word.length,
+					token: word[i],
+					prev: previous_node,
+					next: null
+				};
+				previous_node.next = current_node;
+				this.add_node(queue, previous_node);
+				previous_node = current_node;
+			}
+			while (!queue.is_empty()) {
+				const node = queue.pop();
+				if (node.deleted || !node.next || node.next.deleted) continue;
+				node.deleted = true;
+				node.next.deleted = true;
+				if (node.prev) {
+					const new_previous_node = { ...node.prev };
+					node.prev.deleted = true;
+					node.prev = new_previous_node;
+					if (new_previous_node.prev) new_previous_node.prev.next = new_previous_node;
+					else starting_node = new_previous_node;
+				}
+				const merged = {
+					token: node.token + node.next.token,
+					bias: node.bias,
+					prev: node.prev,
+					next: node.next.next
+				};
+				if (merged.prev) {
+					merged.prev.next = merged;
+					this.add_node(queue, merged.prev);
+				} else starting_node = merged;
+				if (merged.next) {
+					merged.next.prev = merged;
+					this.add_node(queue, merged);
+				}
+			}
+			for (let current_node = starting_node; current_node !== null; current_node = current_node.next) result.push(current_node.token);
+		} else result = word;
+		if (this.continuing_subword_suffix) for (let i = 0; i < result.length - 1; ++i) result[i] += this.continuing_subword_suffix;
+		if (token.length < this.max_length_to_cache) this.cache.put(token, result);
+		return result;
+	}
+	/**
+	* Helper function to add a node to the priority queue.
+	* @param queue
+	* @param node
+	*/
+	add_node(queue, node) {
+		const rank = this.bpe_ranks.get(JSON.stringify([node.token, node.next.token]));
+		if (rank !== void 0) {
+			node.score = rank + node.bias;
+			queue.push(node);
+		}
+	}
+	/**
+	* Encodes the input sequence of tokens using the BPE algorithm and returns the resulting subword tokens.
+	* @param tokens The input sequence of tokens to encode.
+	* @returns The resulting subword tokens after applying the BPE algorithm to the input sequence of tokens.
+	*/
+	encode(tokens) {
+		const output_tokens = [];
+		for (const token of tokens) {
+			if (this.ignore_merges && this.tokens_to_ids.has(token)) {
+				output_tokens.push(token);
+				continue;
+			}
+			const bpe_token_list = this.bpe(token);
+			for (const t of bpe_token_list) if (this.tokens_to_ids.has(t)) output_tokens.push(t);
+			else if (this.byte_fallback) {
+				const byte_tokens = Array.from(this.text_encoder.encode(t)).map((x) => `<0x${x.toString(16).toUpperCase().padStart(2, "0")}>`);
+				if (byte_tokens.every((x) => this.tokens_to_ids.has(x))) output_tokens.push(...byte_tokens);
+				else if (this.unk_token != null) output_tokens.push(this.unk_token);
+			} else if (this.unk_token != null) output_tokens.push(this.unk_token);
+		}
+		return output_tokens;
+	}
+};
+var BPE_default = BPE;
+var Legacy = class extends TokenizerModel_default {
+	/**
+	* Create a Legacy tokenizer model instance.
+	* @param config The configuration object for Legacy tokenizer model.
+	* @param more_config Additional configuration object for the Legacy tokenizer model.
+	*/
+	constructor(config, more_config) {
+		super(config);
+		const vocab = config.vocab;
+		this.tokens_to_ids = object_to_map(more_config.target_lang ? vocab[more_config.target_lang] : vocab);
+		this.bos_token = more_config.bos_token;
+		this.bos_token_id = this.tokens_to_ids.get(this.bos_token);
+		this.eos_token = more_config.eos_token;
+		this.eos_token_id = this.tokens_to_ids.get(this.eos_token);
+		this.pad_token = more_config.pad_token;
+		this.pad_token_id = this.tokens_to_ids.get(this.pad_token);
+		this.unk_token = more_config.unk_token;
+		this.unk_token_id = this.tokens_to_ids.get(this.unk_token);
+		this.vocab = new Array(this.tokens_to_ids.size);
+		for (const [key, value] of this.tokens_to_ids) this.vocab[value] = key;
+	}
+	encode(tokens) {
+		return tokens;
+	}
+};
+var Legacy_default = Legacy;
+function create_tokenizer_model(model_config, config) {
+	switch (model_config.type) {
+		case "WordPiece": return new WordPiece_default(model_config);
+		case "Unigram": return new Unigram_default(model_config, config.eos_token);
+		case "BPE": return new BPE_default(model_config);
+		default:
+			if (model_config.vocab) if (Array.isArray(model_config.vocab)) return new Unigram_default(model_config, config.eos_token);
+			else if (Object.hasOwn(model_config, "continuing_subword_prefix") && Object.hasOwn(model_config, "unk_token")) if (Object.hasOwn(model_config, "merges")) return new BPE_default(model_config);
+			else return new WordPiece_default(model_config);
+			else return new Legacy_default(model_config, {
+				target_lang: config.target_lang,
+				bos_token: config.bos_token,
+				eos_token: config.eos_token,
+				pad_token: config.pad_token,
+				unk_token: config.unk_token
+			});
+			throw new Error(`Unknown TokenizerModel type: ${model_config?.type}`);
+	}
+}
+var create_tokenizer_model_default = create_tokenizer_model;
+var PostProcessor = class extends Callable_default {
+	/**
+	* @param config The configuration for the post-processor.
+	*/
+	constructor(config) {
+		super();
+		this.config = config;
+	}
+	/**
+	* Alias for {@link PostProcessor#post_process}.
+	* @param tokens The text or array of texts to post-process.
+	* @param args Additional arguments required by the post-processing logic.
+	* @returns The post-processed tokens.
+	*/
+	_call(tokens, ...args) {
+		return this.post_process(tokens, ...args);
+	}
+};
+var PostProcessor_default = PostProcessor;
+var TemplateProcessing = class extends PostProcessor_default {
+	/**
+	* Replaces special tokens in the template with actual tokens.
+	* @param tokens The list of tokens for the first sequence.
+	* @param tokens_pair The list of tokens for the second sequence (optional).
+	* @param add_special_tokens Whether to add the special tokens to the beginning and end of the input.
+	* @returns An object containing the list of tokens with the special tokens replaced with actual tokens.
+	*/
+	post_process(tokens, tokens_pair = null, add_special_tokens = true) {
+		const type = tokens_pair === null ? this.config.single : this.config.pair;
+		let processed_tokens = [];
+		let types = [];
+		for (const item of type) if ("SpecialToken" in item) {
+			if (add_special_tokens) {
+				processed_tokens.push(item.SpecialToken.id);
+				types.push(item.SpecialToken.type_id);
+			}
+		} else if ("Sequence" in item) {
+			if (item.Sequence.id === "A") {
+				processed_tokens = merge_arrays(processed_tokens, tokens);
+				types = merge_arrays(types, new Array(tokens.length).fill(item.Sequence.type_id));
+			} else if (item.Sequence.id === "B") {
+				processed_tokens = merge_arrays(processed_tokens, tokens_pair);
+				types = merge_arrays(types, new Array(tokens_pair.length).fill(item.Sequence.type_id));
+			}
+		}
+		return {
+			tokens: processed_tokens,
+			token_type_ids: types
+		};
+	}
+};
+var TemplateProcessing_default = TemplateProcessing;
+var ByteLevel2 = class extends PostProcessor_default {
+	/**
+	* Post process the given tokens.
+	* @param tokens The list of tokens for the first sequence.
+	* @param tokens_pair The list of tokens for the second sequence (optional).
+	* @returns An object containing the post-processed tokens.
+	*/
+	post_process(tokens, tokens_pair = null) {
+		return {
+			tokens,
+			tokens_pair
+		};
+	}
+};
+var ByteLevel_default2 = ByteLevel2;
+var BertProcessing = class extends PostProcessor_default {
+	/**
+	* @param config The configuration for the post-processor.
+	* @param config.cls The special tokens to add to the beginning of the input.
+	* @param config.sep The special tokens to add to the end of the input.
+	*/
+	constructor(config) {
+		super(config);
+		this.sep = config.sep;
+		this.cls = config.cls;
+	}
+	/**
+	* Adds the special tokens to the beginning and end of the input.
+	* @param tokens The input tokens.
+	* @param tokens_pair An optional second set of input tokens.
+	* @param add_special_tokens Whether to add the special tokens to the beginning and end of the input.
+	* @returns The post-processed tokens with the special tokens added to the beginning and end.
+	*/
+	post_process(tokens, tokens_pair = null, add_special_tokens = true) {
+		if (add_special_tokens) tokens = merge_arrays([this.cls[0]], tokens, [this.sep[0]]);
+		let token_type_ids = new Array(tokens.length).fill(0);
+		if (tokens_pair) {
+			const middle = [];
+			const after = add_special_tokens ? [this.sep[0]] : [];
+			tokens = merge_arrays(tokens, middle, tokens_pair, after);
+			token_type_ids = merge_arrays(token_type_ids, new Array(tokens_pair.length + middle.length + after.length).fill(1));
+		}
+		return {
+			tokens,
+			token_type_ids
+		};
+	}
+};
+var BertProcessing_default = BertProcessing;
+var RobertaProcessing = class extends PostProcessor_default {
+	/**
+	* @param config The configuration for the post-processor.
+	* @param config.cls The special tokens to add to the beginning of the input.
+	* @param config.sep The special tokens to add to the end of the input.
+	*/
+	constructor(config) {
+		super(config);
+		this.sep = config.sep;
+		this.cls = config.cls;
+	}
+	/**
+	* Adds the special tokens to the beginning and end of the input.
+	* @param tokens The input tokens.
+	* @param tokens_pair An optional second set of input tokens.
+	* @param add_special_tokens Whether to add the special tokens to the beginning and end of the input.
+	* @returns The post-processed tokens with the special tokens added to the beginning and end.
+	*/
+	post_process(tokens, tokens_pair, add_special_tokens = true) {
+		if (add_special_tokens) tokens = merge_arrays([this.cls[0]], tokens, [this.sep[0]]);
+		let token_type_ids = new Array(tokens.length).fill(0);
+		if (tokens_pair) {
+			const middle = add_special_tokens ? [this.sep[0]] : [];
+			const after = add_special_tokens ? [this.sep[0]] : [];
+			tokens = merge_arrays(tokens, middle, tokens_pair, after);
+			token_type_ids = merge_arrays(token_type_ids, new Array(tokens_pair.length + middle.length + after.length).fill(1));
+		}
+		return {
+			tokens,
+			token_type_ids
+		};
+	}
+};
+var RobertaProcessing_default = RobertaProcessing;
+var Sequence3 = class extends PostProcessor_default {
+	/**
+	* Creates a new instance of Sequence post-processor.
+	* @param config The configuration object.
+	*/
+	constructor(config) {
+		super(config);
+		this.processors = (config.processors ?? []).map((x) => create_post_processor_default(x));
+	}
+	/**
+	* Post process the given tokens.
+	* @param tokens The list of tokens for the first sequence.
+	* @param tokens_pair The list of tokens for the second sequence (optional).
+	* @param add_special_tokens Whether to add the special tokens to the beginning and end of the input.
+	* @returns An object containing the post-processed tokens.
+	*/
+	post_process(tokens, tokens_pair = null, add_special_tokens = true) {
+		let processed_tokens = {
+			tokens,
+			tokens_pair
+		};
+		for (const processor of this.processors) processed_tokens = processor.post_process(processed_tokens.tokens, processed_tokens.tokens_pair, add_special_tokens);
+		return processed_tokens;
+	}
+};
+var Sequence_default3 = Sequence3;
+function create_post_processor(config) {
+	if (config === null) return null;
+	switch (config.type) {
+		case "TemplateProcessing": return new TemplateProcessing_default(config);
+		case "ByteLevel": return new ByteLevel_default2(config);
+		case "BertProcessing": return new BertProcessing_default(config);
+		case "RobertaProcessing": return new RobertaProcessing_default(config);
+		case "Sequence": return new Sequence_default3(config);
+		default: throw new Error(`Unknown PostProcessor type: ${config.type}`);
+	}
+}
+var create_post_processor_default = create_post_processor;
+var Decoder = class extends Callable_default {
+	/**
+	* Creates an instance of `Decoder`.
+	* @param config The configuration object.
+	**/
+	constructor(config) {
+		super();
+		this.config = config;
+		this.added_tokens = [];
+		this.end_of_word_suffix = null;
+		this.trim_offsets = "trim_offsets" in config ? config.trim_offsets : false;
+	}
+	/**
+	* Calls the `decode` method.
+	*
+	* @param tokens The list of tokens.
+	* @returns The decoded string.
+	*/
+	_call(tokens) {
+		return this.decode(tokens);
+	}
+	/**
+	* Decodes a list of tokens.
+	* @param tokens The list of tokens.
+	* @returns The decoded string.
+	*/
+	decode(tokens) {
+		return this.decode_chain(tokens).join("");
+	}
+};
+var Decoder_default = Decoder;
+var ByteLevel3 = class extends Decoder_default {
+	/**
+	* Create a `ByteLevelDecoder` object.
+	*/
+	constructor(config) {
+		super(config);
+		this.byte_decoder = UNICODE_TO_BYTES;
+		this.text_decoder = new TextDecoder("utf-8", {
+			fatal: false,
+			ignoreBOM: true
+		});
+		this.end_of_word_suffix = null;
+	}
+	/**
+	* Convert an array of tokens to string by decoding each byte.
+	* @param tokens Array of tokens to be decoded.
+	* @returns The decoded string.
+	*/
+	convert_tokens_to_string(tokens) {
+		const text = tokens.join("");
+		const byte_array = new Uint8Array([...text].map((c) => this.byte_decoder[c]));
+		return this.text_decoder.decode(byte_array);
+	}
+	decode_chain(tokens) {
+		const sub_texts = [];
+		let current_sub_text = [];
+		for (const token of tokens) if (this.added_tokens.find((x) => x.content === token) !== void 0) {
+			if (current_sub_text.length > 0) {
+				sub_texts.push(this.convert_tokens_to_string(current_sub_text));
+				current_sub_text = [];
+			}
+			sub_texts.push(token);
+		} else current_sub_text.push(token);
+		if (current_sub_text.length > 0) sub_texts.push(this.convert_tokens_to_string(current_sub_text));
+		return sub_texts;
+	}
+};
+var ByteLevel_default3 = ByteLevel3;
+var WordPiece = class extends Decoder_default {
+	/**
+	* Creates a new instance of WordPieceDecoder.
+	* @param config The configuration object.
+	*/
+	constructor(config) {
+		super(config);
+		this.cleanup = config.cleanup;
+	}
+	decode_chain(tokens) {
+		return tokens.map((token, i) => {
+			if (i !== 0) {
+				const prefix = this.config.prefix;
+				if (prefix && token.startsWith(prefix)) token = token.replace(prefix, "");
+				else token = " " + token;
+			}
+			if (this.cleanup) token = clean_up_tokenization(token);
+			return token;
+		});
+	}
+};
+var WordPiece_default2 = WordPiece;
+var Metaspace2 = class extends Decoder_default {
+	/**
+	* Constructs a new MetaspaceDecoder object.
+	* @param config The configuration object for the MetaspaceDecoder.
+	*/
+	constructor(config) {
+		super(config);
+		this.replacement = config.replacement ?? "▁";
+	}
+	decode_chain(tokens) {
+		const result = [];
+		for (let i = 0; i < tokens.length; ++i) {
+			let normalized = tokens[i].replaceAll(this.replacement, " ");
+			if (i == 0 && normalized.startsWith(" ")) normalized = normalized.substring(1);
+			result.push(normalized);
+		}
+		return result;
+	}
+};
+var Metaspace_default2 = Metaspace2;
+var BPE2 = class extends Decoder_default {
+	constructor(config) {
+		super(config);
+		this.suffix = config.suffix ?? "";
+	}
+	decode_chain(tokens) {
+		return tokens.map((token, i) => {
+			return token.replaceAll(this.suffix, i === tokens.length - 1 ? "" : " ");
+		});
+	}
+};
+var BPE_default2 = BPE2;
+var CTC = class extends Decoder_default {
+	constructor(config) {
+		super(config);
+		this.pad_token = config.pad_token ?? "";
+		this.word_delimiter_token = config.word_delimiter_token ?? "";
+		this.cleanup = config.cleanup;
+	}
+	/**
+	* Converts a connectionist-temporal-classification (CTC) output tokens into a single string.
+	* @param tokens Array of tokens to be decoded.
+	* @returns The decoded string.
+	*/
+	convert_tokens_to_string(tokens) {
+		if (tokens.length === 0) return "";
+		const grouped_tokens = [tokens[0]];
+		for (let i = 1; i < tokens.length; ++i) if (tokens[i] !== grouped_tokens.at(-1)) grouped_tokens.push(tokens[i]);
+		let text = grouped_tokens.filter((token) => token !== this.pad_token).join("");
+		if (this.cleanup) text = clean_up_tokenization(text).replaceAll(this.word_delimiter_token, " ").trim();
+		return text;
+	}
+	decode_chain(tokens) {
+		return [this.convert_tokens_to_string(tokens)];
+	}
+};
+var CTC_default = CTC;
+var Sequence4 = class extends Decoder_default {
+	/**
+	* Creates a new instance of DecoderSequence.
+	* @param config The configuration object.
+	*/
+	constructor(config) {
+		super(config);
+		this.decoders = (config.decoders ?? []).map((x) => create_decoder_default(x));
+	}
+	decode_chain(tokens) {
+		return this.decoders.reduce((toks, decoder) => {
+			return decoder.decode_chain(toks);
+		}, tokens);
+	}
+};
+var Sequence_default4 = Sequence4;
+var Replace3 = class extends Decoder_default {
+	decode_chain(tokens) {
+		const pattern = create_pattern(this.config.pattern);
+		const content = this.config.content ?? "";
+		return pattern === null ? tokens : tokens.map((token) => token.replaceAll(pattern, content));
+	}
+};
+var Replace_default3 = Replace3;
+var Fuse = class extends Decoder_default {
+	decode_chain(tokens) {
+		return [tokens.join("")];
+	}
+};
+var Fuse_default = Fuse;
+var Strip2 = class extends Decoder_default {
+	constructor(config) {
+		super(config);
+		this.content = config.content ?? "";
+		this.start = config.start ?? 0;
+		this.stop = config.stop ?? 0;
+	}
+	decode_chain(tokens) {
+		return tokens.map((token) => {
+			let start_cut = 0;
+			for (let i = 0; i < this.start; ++i) if (token[i] === this.content) {
+				start_cut = i + 1;
+				continue;
+			} else break;
+			let stop_cut = token.length;
+			for (let i = 0; i < this.stop; ++i) {
+				const index = token.length - i - 1;
+				if (token[index] === this.content) {
+					stop_cut = index;
+					continue;
+				} else break;
+			}
+			return token.slice(start_cut, stop_cut);
+		});
+	}
+};
+var Strip_default2 = Strip2;
+var ByteFallback = class extends Decoder_default {
+	constructor(config) {
+		super(config);
+		this.text_decoder = new TextDecoder();
+	}
+	decode_chain(tokens) {
+		const new_tokens = [];
+		let previous_byte_tokens = [];
+		for (const token of tokens) {
+			let bytes = null;
+			if (token.length === 6 && token.startsWith("<0x") && token.endsWith(">")) {
+				const byte = parseInt(token.slice(3, 5), 16);
+				if (!isNaN(byte)) bytes = byte;
+			}
+			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);
+					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);
+			previous_byte_tokens = [];
+		}
+		return new_tokens;
+	}
+};
+var ByteFallback_default = ByteFallback;
+function create_decoder(config) {
+	if (config === null) return null;
+	switch (config.type) {
+		case "ByteLevel": return new ByteLevel_default3(config);
+		case "WordPiece": return new WordPiece_default2(config);
+		case "Metaspace": return new Metaspace_default2(config);
+		case "BPEDecoder": return new BPE_default2(config);
+		case "CTC": return new CTC_default(config);
+		case "Sequence": return new Sequence_default4(config);
+		case "Replace": return new Replace_default3(config);
+		case "Fuse": return new Fuse_default(config);
+		case "Strip": return new Strip_default2(config);
+		case "ByteFallback": return new ByteFallback_default(config);
+		default: throw new Error(`Unknown Decoder type: ${config.type}`);
+	}
+}
+var create_decoder_default = create_decoder;
+var Tokenizer = class {
+	constructor(tokenizer, config) {
+		const tokenizer_error = validate_object(tokenizer, "Tokenizer", [
+			"model",
+			"decoder",
+			"post_processor",
+			"pre_tokenizer",
+			"normalizer"
+		]);
+		if (tokenizer_error) throw new Error(tokenizer_error);
+		const config_error = validate_object(config, "Config");
+		if (config_error) throw new Error(config_error);
+		this.tokenizer = tokenizer;
+		this.config = config;
+		this.normalizer = create_normalizer_default(this.tokenizer.normalizer);
+		this.pre_tokenizer = create_pre_tokenizer_default(this.tokenizer.pre_tokenizer);
+		this.model = create_tokenizer_model_default(this.tokenizer.model, this.config);
+		this.post_processor = create_post_processor_default(this.tokenizer.post_processor);
+		this.decoder = create_decoder_default(this.tokenizer.decoder);
+		this.special_tokens = [];
+		this.all_special_ids = [];
+		this.added_tokens = [];
+		const unnormalized_contents = [];
+		const normalized_contents = [];
+		this.added_tokens_map = /* @__PURE__ */ new Map();
+		for (const added_token of this.tokenizer.added_tokens) {
+			const token = new AddedToken_default(added_token);
+			this.added_tokens.push(token);
+			this.model.tokens_to_ids.set(token.content, token.id);
+			this.model.vocab[token.id] = token.content;
+			if (token.special) {
+				this.special_tokens.push(token.content);
+				this.all_special_ids.push(token.id);
+			}
+			this.added_tokens_map.set(token.content, token);
+			if (token.normalized && this.normalizer !== null) {
+				const normalized_content = this.normalizer(token.content);
+				normalized_contents.push(normalized_content);
+				this.added_tokens_map.set(normalized_content, token);
+			} else unnormalized_contents.push(token.content);
+		}
+		(this.config.additional_special_tokens ?? []).forEach((token) => {
+			if (!this.special_tokens.includes(token)) this.special_tokens.push(token);
+		});
+		if (this.decoder) {
+			this.decoder.added_tokens = this.added_tokens;
+			this.decoder.end_of_word_suffix = this.model.end_of_word_suffix;
+		}
+		this.splitter_unnormalized = new DictionarySplitter_default(unnormalized_contents);
+		this.splitter_normalized = new DictionarySplitter_default(normalized_contents);
+		this.remove_space = this.config.remove_space;
+		this.clean_up_tokenization_spaces = this.config.clean_up_tokenization_spaces ?? true;
+		this.do_lowercase_and_remove_accent = this.config.do_lowercase_and_remove_accent ?? false;
+	}
+	encode(text, { text_pair = null, add_special_tokens = true, return_token_type_ids = null } = {}) {
+		const { tokens, token_type_ids } = this.tokenize_helper(text, {
+			text_pair,
+			add_special_tokens
+		});
+		const input_ids = tokens.map((t) => this.added_tokens_map.get(t)?.id ?? this.model.tokens_to_ids.get(t) ?? this.model.unk_token_id);
+		const result = {
+			ids: input_ids,
+			tokens,
+			attention_mask: new Array(input_ids.length).fill(1)
+		};
+		if (return_token_type_ids && token_type_ids) result.token_type_ids = token_type_ids;
+		return result;
+	}
+	decode(token_ids, options = {}) {
+		if (!Array.isArray(token_ids) || token_ids.length === 0 || !is_integral_number(token_ids[0])) throw Error("token_ids must be a non-empty array of integers.");
+		let tokens = token_ids.map((i) => this.model.vocab[Number(i)] ?? this.model.unk_token);
+		if (options.skip_special_tokens) tokens = tokens.filter((x) => !this.special_tokens.includes(x));
+		let decoded = this.decoder ? this.decoder(tokens) : tokens.join(" ");
+		if (this.decoder && this.decoder.end_of_word_suffix) {
+			decoded = decoded.replaceAll(this.decoder.end_of_word_suffix, " ");
+			if (options.skip_special_tokens) decoded = decoded.trim();
+		}
+		if (options.clean_up_tokenization_spaces ?? this.clean_up_tokenization_spaces) decoded = clean_up_tokenization(decoded);
+		return decoded;
+	}
+	/**
+	* Converts a string into a sequence of tokens.
+	* @param text The sequence to be encoded.
+	* @param options An optional object containing the following properties:
+	* @returns The list of tokens.
+	*/
+	tokenize(text, { text_pair = null, add_special_tokens = false } = {}) {
+		return this.tokenize_helper(text, {
+			text_pair,
+			add_special_tokens
+		}).tokens;
+	}
+	encode_text(text) {
+		if (text === null) return null;
+		const sections = this.splitter_unnormalized.split(text);
+		sections.forEach((section, i) => {
+			const added_token = this.added_tokens_map.get(section);
+			if (added_token) {
+				if (added_token.lstrip && i > 0) sections[i - 1] = sections[i - 1].trimEnd();
+				if (added_token.rstrip && i < sections.length - 1) sections[i + 1] = sections[i + 1].trimStart();
+			}
+		});
+		return sections.flatMap((processed_text, section_index) => {
+			if (processed_text.length === 0) return [];
+			if (this.added_tokens_map.has(processed_text)) return [processed_text];
+			if (this.remove_space === true) processed_text = processed_text.trim().split(/\s+/).join(" ");
+			if (this.do_lowercase_and_remove_accent) processed_text = lowercase_and_remove_accents(processed_text);
+			if (this.normalizer !== null) processed_text = this.normalizer(processed_text);
+			if (processed_text.length === 0) return [];
+			const subsections = this.splitter_normalized.split(processed_text);
+			subsections.forEach((subsection, j) => {
+				const added_token = this.added_tokens_map.get(subsection);
+				if (added_token) {
+					if (added_token.lstrip && j > 0) subsections[j - 1] = subsections[j - 1].trimEnd();
+					if (added_token.rstrip && j < subsections.length - 1) subsections[j + 1] = subsections[j + 1].trimStart();
+				}
+			});
+			return subsections.flatMap((subsection) => {
+				if (subsection.length === 0) return [];
+				if (this.added_tokens_map.has(subsection)) return [subsection];
+				const section_tokens = this.pre_tokenizer !== null ? this.pre_tokenizer(subsection, { section_index }) : [subsection];
+				return this.model(section_tokens);
+			});
+		});
+	}
+	tokenize_helper(text, { text_pair = null, add_special_tokens = true }) {
+		const tokens1 = this.encode_text(text);
+		const tokens2 = this.encode_text(text_pair || null);
+		return this.post_processor ? this.post_processor(tokens1, tokens2, add_special_tokens) : { tokens: merge_arrays(tokens1 ?? [], tokens2 ?? []) };
+	}
+	/**
+	* Converts a token string to its corresponding token ID.
+	* @param token The token string to convert.
+	* @returns The token ID, or undefined if the token is not in the vocabulary.
+	*/
+	token_to_id(token) {
+		return this.model.tokens_to_ids.get(token);
+	}
+	/**
+	* Converts a token ID to its corresponding token string.
+	* @param id The token ID to convert.
+	* @returns The token string, or undefined if the ID is not in the vocabulary.
+	*/
+	id_to_token(id) {
+		return this.model.vocab[id];
+	}
+	/**
+	* Returns a mapping of token IDs to AddedToken objects for all added tokens.
+	* @returns A Map where keys are token IDs and values are AddedToken objects.
+	*/
+	get_added_tokens_decoder() {
+		const decoder = /* @__PURE__ */ new Map();
+		for (const token of this.added_tokens) decoder.set(token.id, token);
+		return decoder;
+	}
+	/**
+	* Get the underlying vocabulary
+	* @param with_added_tokens Whether to include the added tokens
+	* @returns The vocabulary
+	*/
+	get_vocab(with_added_tokens = true) {
+		const vocab = /* @__PURE__ */ new Map();
+		for (let i = 0; i < this.model.vocab.length; ++i) {
+			const token = this.model.vocab[i];
+			if (with_added_tokens || !this.added_tokens_map.has(token)) vocab.set(token, i);
+		}
+		return vocab;
+	}
+};
+var Tokenizer_default = Tokenizer;
+
+//#endregion
+//#region src/ai/image.ts
+function modelCacheRoot(manifest = flux2Klein4B8BitAbliterated) {
+	return files.directory(files.paths.models, manifest.directory);
+}
+function assertImageModel(model) {
+	if (model !== flux2Klein4B8BitAbliterated.model) throw new AIError("invalid_model", `Unsupported image model: ${model}`);
+}
+function modelRootFromOptions(modelRoot) {
+	return modelRoot ?? modelCacheRoot().path;
+}
+function downloadConcurrency(value) {
+	if (value === void 0) return 2;
+	if (!Number.isInteger(value)) throw new AIError("invalid_model", "concurrency must be an integer");
+	return Math.min(4, Math.max(1, value));
+}
+async function runConcurrent(items, concurrency, worker) {
+	let nextIndex = 0;
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+		while (nextIndex < items.length) {
+			const item = items[nextIndex];
+			nextIndex += 1;
+			await worker(item);
+		}
+	});
+	await Promise.all(workers);
+}
+function hfResolveUrl(repo, revision, path) {
+	const encodedRepo = repo.split("/").map(encodeURIComponent).join("/");
+	const encodedPath = path.split("/").map(encodeURIComponent).join("/");
+	return `https://huggingface.co/${encodedRepo}/resolve/${encodeURIComponent(revision)}/${encodedPath}`;
+}
+const imageDimensionMultiple = 16;
+const minimumImageDimension = 64;
+const defaultImageLongSide = 1152;
+const aspectRatioValues = {
+	"1:1": [1, 1],
+	"16:9": [16, 9],
+	"9:16": [9, 16],
+	"4:3": [4, 3],
+	"3:2": [3, 2],
+	"2:3": [2, 3],
+	"21:9": [21, 9]
+};
+function normalizedDimension(value) {
+	return Math.max(minimumImageDimension, Math.floor(value / imageDimensionMultiple) * imageDimensionMultiple);
+}
+function normalizeImageSize(size, maxLongSide = defaultImageLongSide) {
+	if (!Number.isFinite(size.width) || size.width <= 0) throw new AIError("invalid_model", "size.width must be positive");
+	if (!Number.isFinite(size.height) || size.height <= 0) throw new AIError("invalid_model", "size.height must be positive");
+	if (maxLongSide !== false && (!Number.isInteger(maxLongSide) || maxLongSide < minimumImageDimension)) throw new AIError("invalid_model", `maxLongSide must be false or an integer of at least ${minimumImageDimension}`);
+	const scale = maxLongSide === false ? 1 : Math.min(1, maxLongSide / Math.max(size.width, size.height));
+	return {
+		width: normalizedDimension(size.width * scale),
+		height: normalizedDimension(size.height * scale)
+	};
+}
+function imageSizeForPreset(aspectRatio, maxLongSide = defaultImageLongSide) {
+	const ratio = aspectRatioValues[aspectRatio];
+	if (!ratio) throw new AIError("invalid_model", `Unsupported image aspect ratio: ${aspectRatio}`);
+	assertPositiveInteger(maxLongSide, "maxLongSide");
+	const [widthRatio, heightRatio] = ratio;
+	return normalizeImageSize(widthRatio >= heightRatio ? {
+		width: maxLongSide,
+		height: maxLongSide * heightRatio / widthRatio
+	} : {
+		width: maxLongSide * widthRatio / heightRatio,
+		height: maxLongSide
+	}, maxLongSide);
+}
+function imageLoRARoot() {
+	return files.directory(files.paths.models, "image-loras");
+}
+function safeCacheName(value, name) {
+	const trimmed = value.trim();
+	if (!trimmed) throw new AIError("invalid_model", `${name} must not be empty`);
+	return trimmed.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function sourceFileName(lora) {
+	if (lora.source.type === "local") return lora.source.path.split("/").pop() || `${lora.id}.safetensors`;
+	if (lora.source.type === "url") return lora.source.filename ?? lora.source.url.split("/").pop() ?? `${lora.id}.safetensors`;
+	return lora.source.path?.split("/").pop() || `${lora.id}.safetensors`;
+}
+function assertLoRAScale(scale, name = "lora.scale") {
+	const value = scale ?? 1;
+	if (!Number.isFinite(value) || value <= 0) throw new AIError("invalid_model", `${name} must be a positive number`);
+	return value;
+}
+function assertLoRADefinition(lora) {
+	safeCacheName(lora.id, "lora.id");
+	assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
+	imageSigmaSchedule([lora.metadata?.sigmaSchedule]);
+	if (lora.metadata?.baseModel !== void 0) assertImageModel(lora.metadata.baseModel);
+	if (lora.metadata?.precision !== void 0 && ![
+		"float16",
+		"bfloat16",
+		"float32"
+	].includes(lora.metadata.precision)) throw new AIError("invalid_model", "lora.metadata.precision is unsupported");
+}
+function assertLoRACompatibility(lora, model) {
+	if (lora.metadata?.baseModel && lora.metadata.baseModel !== model) throw new AIError("invalid_model", `LoRA ${lora.id} targets ${lora.metadata.baseModel}, not ${model}`);
+}
+const commonLoRAFileNames = [
+	"pytorch_lora_weights.safetensors",
+	"adapter_model.safetensors",
+	"lora.safetensors",
+	"model.safetensors"
+];
+async function resolveHuggingFaceLoRA(lora, options) {
+	if (lora.source.type !== "huggingface" || lora.source.path) return lora;
+	const revision = lora.source.revision ?? "main";
+	const manifestFile = imageLoRARoot().directory(safeCacheName(lora.id, "lora.id")).file("manifest.json");
+	if ((await manifestFile.stat()).type === "file") {
+		const manifest = await manifestFile.json();
+		if (isRecord(manifest) && isRecord(manifest.source) && manifest.source.type === "huggingface" && manifest.source.repo === lora.source.repo && (manifest.source.revision ?? "main") === revision && typeof manifest.source.path === "string") return {
+			...lora,
+			source: {
+				...lora.source,
+				revision,
+				path: manifest.source.path,
+				bytes: lora.source.bytes ?? (typeof manifest.source.bytes === "number" ? manifest.source.bytes : void 0)
+			}
+		};
+	}
+	const encodedRepo = lora.source.repo.split("/").map(encodeURIComponent).join("/");
+	const response = await fetch(`https://huggingface.co/api/models/${encodedRepo}/revision/${encodeURIComponent(revision)}`, {
+		headers: options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0,
+		signal: options.signal
+	});
+	if (!response.ok) throw new AIError("invalid_model", `Unable to inspect Hugging Face LoRA ${lora.source.repo}: ${response.status}`);
+	const value = await response.json();
+	const siblings = isRecord(value) && Array.isArray(value.siblings) ? value.siblings.flatMap((item) => {
+		if (!isRecord(item) || typeof item.rfilename !== "string") return [];
+		return [{
+			path: item.rfilename,
+			bytes: typeof item.size === "number" ? item.size : void 0
+		}];
+	}) : [];
+	const common = commonLoRAFileNames.map((name) => siblings.find((file) => file.path === name)).find(Boolean);
+	const safetensors = siblings.filter((file) => file.path.endsWith(".safetensors"));
+	const selected = common ?? (safetensors.length === 1 ? safetensors[0] : void 0);
+	if (!selected) {
+		const candidates = safetensors.map((file) => file.path).join(", ");
+		throw new AIError("invalid_model", candidates ? `Multiple LoRA weights found for ${lora.id}; set source.path to one of: ${candidates}` : `No .safetensors LoRA weight found for ${lora.id}`);
+	}
+	return {
+		...lora,
+		source: {
+			...lora.source,
+			revision,
+			path: selected.path,
+			bytes: lora.source.bytes ?? selected.bytes
+		}
+	};
+}
+function loraUrl(lora) {
+	if (lora.source.type === "url") return lora.source.url;
+	if (lora.source.type === "huggingface") {
+		if (!lora.source.path) return void 0;
+		return hfResolveUrl(lora.source.repo, lora.source.revision ?? "main", lora.source.path);
+	}
+}
+function loraExpectedBytes(lora) {
+	return lora.source.type === "local" ? void 0 : lora.source.bytes;
+}
+function hasSafetensorsHeader(size) {
+	return size !== void 0 && size > 8;
+}
+function loraHeaders(lora, accessToken) {
+	return lora.source.type === "huggingface" && accessToken ? { Authorization: `Bearer ${accessToken}` } : void 0;
+}
+function cachedLoRAFile(lora) {
+	const id = safeCacheName(lora.id, "lora.id");
+	return imageLoRARoot().directory(id).file(safeCacheName(sourceFileName(lora), "lora filename"));
+}
+async function ensureModelFile(input) {
+	const destination = files.file(input.modelRoot, input.file.destination);
+	const stat = await destination.stat();
+	if (stat.type === "file" && stat.size === input.file.bytes) {
+		input.onProgress?.({
+			model: flux2Klein4B8BitAbliterated.model,
+			file: input.file.destination,
+			index: input.index,
+			total: input.total,
+			bytesWritten: input.file.bytes,
+			totalBytes: input.file.bytes,
+			fraction: 1
+		});
+		return;
+	}
+	await destination.download(hfResolveUrl(input.file.repo, input.file.revision, input.file.source), {
+		headers: input.headers,
+		expectedBytes: input.file.bytes,
+		atomic: true,
+		resume: true,
+		onProgress(progress) {
+			input.onProgress?.({
+				model: flux2Klein4B8BitAbliterated.model,
+				file: input.file.destination,
+				index: input.index,
+				total: input.total,
+				...progress
+			});
+		}
+	}).result;
+}
+async function writePreparedManifest(modelRoot) {
+	await files.file(modelRoot, "manifest.json").write(JSON.stringify(flux2Klein4B8BitAbliterated, null, 2));
+}
+async function imageModelState(model, modelRoot) {
+	assertImageModel(model);
+	let bytesPresent = 0;
+	const missingFiles = [];
+	const invalidFiles = [];
+	for (const file of flux2KleinModelFiles) {
+		const stat = await files.file(modelRoot, file.destination).stat();
+		if (stat.type !== "file") {
+			missingFiles.push(file.destination);
+			continue;
+		}
+		bytesPresent += Math.min(stat.size ?? 0, file.bytes);
+		if (stat.size !== file.bytes) invalidFiles.push(file.destination);
+	}
+	const installed = missingFiles.length === 0;
+	const manifestStat = await files.file(modelRoot, "manifest.json").stat();
+	if (manifestStat.type !== "file") missingFiles.push("manifest.json");
+	return {
+		model,
+		modelRoot,
+		paths: fluxImageModelPaths(modelRoot),
+		installed,
+		verified: installed && invalidFiles.length === 0 && manifestStat.type === "file",
+		bytesPresent,
+		totalBytes: flux2KleinTotalBytes,
+		missingFiles,
+		invalidFiles
+	};
+}
+function tokenArray(value, name) {
+	const candidate = isRecord(value) && "data" in value ? value.data : value;
+	const values = Array.isArray(candidate) ? candidate : ArrayBuffer.isView(candidate) ? Array.from(candidate) : void 0;
+	if (!values) throw new AIError("invalid_message", `Tokenizer did not return ${name}`);
+	return values.map((token) => {
+		const number = typeof token === "bigint" ? Number(token) : token;
+		if (!Number.isInteger(number) || number < 0) throw new AIError("invalid_message", `${name} must contain token ids`);
+		return number;
+	});
+}
+async function createFluxTokenizer(modelRoot) {
+	const paths = fluxImageModelPaths(modelRoot);
+	const tokenizer = new Tokenizer_default(await files.file(paths.textEncoderPath, "tokenizer.json").json(), await files.file(paths.textEncoderPath, "tokenizer_config.json").json());
+	const padTokenId = 151643;
+	return ({ prompt, maxLength }) => {
+		const inputIds = tokenArray(tokenizer.encode(formatQwen3KleinPrompt(prompt)).ids, "inputIds").slice(0, maxLength);
+		const attentionMask = inputIds.map(() => 1);
+		while (inputIds.length < maxLength) {
+			inputIds.push(padTokenId);
+			attentionMask.push(0);
+		}
+		return {
+			inputIds,
+			attentionMask
+		};
+	};
+}
+function formatQwen3KleinPrompt(prompt) {
+	return [
+		"<|im_start|>user",
+		`${prompt.replaceAll("[IMG]", "")}<|im_end|>`,
+		"<|im_start|>assistant",
+		"<think>",
+		"",
+		"</think>",
+		""
+	].join("\n");
+}
+function assertPositiveInteger(value, name) {
+	if (!Number.isInteger(value) || value <= 0) throw new AIError("invalid_model", `${name} must be a positive integer`);
+}
+function assertUnitInterval(value, name) {
+	if (!Number.isFinite(value) || value <= 0 || value > 1) throw new AIError("invalid_model", `${name} must be greater than 0 and at most 1`);
+}
+function filePathFromUri(value, name) {
+	const path = value.trim();
+	if (!path) throw new AIError("invalid_message", `${name} must not be empty`);
+	if (!path.startsWith("file://")) return path;
+	try {
+		return decodeURIComponent(new URL(path).pathname);
+	} catch (error) {
+		throw new AIError("invalid_message", `Invalid ${name} file URI`, error);
+	}
+}
+function assertTokenArray(value, name) {
+	if (value.length === 0) throw new AIError("invalid_message", `${name} must not be empty`);
+	for (const token of value) if (!Number.isInteger(token) || token < 0) throw new AIError("invalid_message", `${name} must contain token ids`);
+}
+function imageResult(value, 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");
+	const result = value;
+	const metadata = isRecord(result.metadata) ? result.metadata : {};
+	return {
+		uri: value.uri,
+		width: value.width,
+		height: value.height,
+		model: value.model,
+		metadata: {
+			...fallbackMetadata,
+			model: metadata.model === value.model ? metadata.model : fallbackMetadata.model,
+			width: typeof metadata.width === "number" ? metadata.width : value.width,
+			height: typeof metadata.height === "number" ? metadata.height : value.height,
+			steps: typeof metadata.steps === "number" ? metadata.steps : fallbackMetadata.steps,
+			guidance: typeof metadata.guidance === "number" ? metadata.guidance : fallbackMetadata.guidance,
+			strength: typeof metadata.strength === "number" ? metadata.strength : fallbackMetadata.strength,
+			seed: typeof metadata.seed === "number" ? metadata.seed : fallbackMetadata.seed,
+			elapsedMs: typeof metadata.elapsedMs === "number" ? metadata.elapsedMs : fallbackMetadata.elapsedMs,
+			appliedLoRAs: Array.isArray(metadata.appliedLoRAs) ? metadata.appliedLoRAs.flatMap((item) => {
+				if (!isRecord(item) || typeof item.path !== "string") return [];
+				return [{
+					id: typeof item.id === "string" ? item.id : void 0,
+					path: item.path,
+					scale: typeof item.scale === "number" ? item.scale : 1
+				}];
+			}) : fallbackMetadata.appliedLoRAs
+		}
+	};
+}
+async function withImageStage(stage, operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		if (error instanceof ImageGenerationError) throw error;
+		if (error instanceof AIError && error.code === "generation_canceled") throw error;
+		throw new ImageGenerationError(stage, error instanceof Error ? error.message : String(error), error);
+	}
+}
+function imagegenProgress(value) {
+	const currentStep = value.currentStep;
+	const totalSteps = value.totalSteps;
+	if (typeof currentStep !== "number" || !Number.isFinite(currentStep) || typeof totalSteps !== "number" || !Number.isFinite(totalSteps) || totalSteps <= 0) return;
+	return {
+		currentStep,
+		totalSteps,
+		fraction: Math.max(0, Math.min(1, currentStep / totalSteps))
+	};
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new AIError("generation_canceled", "Image generation canceled");
+}
+function nativeErrorStage(error) {
+	const stage = (error instanceof Error ? error.message : String(error)).match(/^\[(download|tokenize|encode|denoise|decode|write)]\s/)?.[1] ?? (isRecord(error) && typeof error.stage === "string" ? error.stage : isRecord(error) && isRecord(error.userInfo) && typeof error.userInfo.stage === "string" ? error.userInfo.stage : void 0);
+	return stage === "download" || stage === "tokenize" || stage === "encode" || stage === "denoise" || stage === "decode" || stage === "write" ? stage : void 0;
+}
+function nativeErrorMessage(error) {
+	return (error instanceof Error ? error.message : String(error)).replace(/^\[(download|tokenize|encode|denoise|decode|write)]\s*/, "");
+}
+async function prepareImageModel(options = {}) {
+	const model = options.model ?? flux2Klein4B8BitAbliterated.model;
+	assertImageModel(model);
+	const root = modelCacheRoot();
+	await root.create({ recursive: true });
+	const headers = options.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : void 0;
+	const total = flux2KleinModelFiles.length;
+	const bytesByFile = /* @__PURE__ */ new Map();
+	const emitProgress = (progress) => {
+		const file = flux2KleinModelFiles.find((candidate) => candidate.destination === progress.file);
+		const bytesWritten = file ? Math.min(progress.bytesWritten, file.bytes) : progress.bytesWritten;
+		bytesByFile.set(progress.file, bytesWritten);
+		const modelBytesWritten = Array.from(bytesByFile.values()).reduce((sum, bytes) => sum + bytes, 0);
+		options.onProgress?.({
+			...progress,
+			bytesWritten,
+			modelBytesWritten,
+			totalModelBytes: flux2KleinTotalBytes,
+			modelFraction: modelBytesWritten / flux2KleinTotalBytes
+		});
+	};
+	const missingFiles = [];
+	for (const [index, file] of flux2KleinModelFiles.entries()) {
+		const stat = await files.file(root.path, file.destination).stat();
+		if (stat.type === "file" && stat.size === file.bytes) emitProgress({
+			model,
+			file: file.destination,
+			index: index + 1,
+			total,
+			bytesWritten: file.bytes,
+			totalBytes: file.bytes,
+			fraction: 1
+		});
+		else missingFiles.push({
+			file,
+			index: index + 1
+		});
+	}
+	await runConcurrent(missingFiles, downloadConcurrency(options.concurrency), async ({ file, index }) => {
+		await ensureModelFile({
+			modelRoot: root.path,
+			file,
+			headers,
+			index,
+			total,
+			onProgress: emitProgress
+		});
+	});
+	await writePreparedManifest(root.path);
+	return {
+		model,
+		...fluxImageModelPaths(root.path),
+		tokenizer: await createFluxTokenizer(root.path)
+	};
+}
+async function verifyImageModel(options = {}) {
+	return imageModelState(options.model ?? flux2Klein4B8BitAbliterated.model, modelRootFromOptions(options.modelRoot));
+}
+async function listImageModels(options = {}) {
+	return [await imageModelState(flux2Klein4B8BitAbliterated.model, modelRootFromOptions(options.modelRoot))];
+}
+async function deleteImageModel(options = {}) {
+	assertImageModel(options.model ?? flux2Klein4B8BitAbliterated.model);
+	await files.directory(modelRootFromOptions(options.modelRoot)).delete({ recursive: true });
+}
+async function imageMemoryTelemetry() {
+	const value = await bridge().imageMemoryTelemetry?.();
+	if (!value) throw new AIError("image_generation_failed", "Image service is unavailable");
+	return value;
+}
+async function unloadImageModel() {
+	return await bridge().unloadImageModel?.() ?? false;
+}
+async function upscaleImage(options) {
+	throwIfAborted(options.signal);
+	const scale = normalizeUpscaleScale(options.scale);
+	const value = await bridge().upscaleImage?.({
+		imagePath: filePathFromUri(options.image, "image"),
+		scale
+	});
+	throwIfAborted(options.signal);
+	if (!value || typeof value.uri !== "string" || !Number.isInteger(value.width) || !Number.isInteger(value.height) || value.scale !== scale) throw new AIError("image_generation_failed", "Native image upscaling returned an invalid result");
+	return value;
+}
+async function prepareImageLoRA(lora, options = {}) {
+	assertLoRADefinition(lora);
+	const resolvedDefinition = await resolveHuggingFaceLoRA(lora, options);
+	const id = safeCacheName(lora.id, "lora.id");
+	const scale = assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
+	if (resolvedDefinition.source.type === "local") {
+		const path = filePathFromUri(resolvedDefinition.source.path, `lora ${id}`);
+		const stat$1 = await files.file(path).stat();
+		if (stat$1.type !== "file") throw new AIError("invalid_model", `Missing LoRA file: ${path}`);
+		if (!hasSafetensorsHeader(stat$1.size)) throw new AIError("invalid_model", `Invalid LoRA safetensors file: ${path}`);
+		return {
+			id: lora.id,
+			description: lora.description,
+			path,
+			uri: stat$1.uri,
+			scale,
+			source: resolvedDefinition.source,
+			metadata: lora.metadata
+		};
+	}
+	const url = loraUrl(resolvedDefinition);
+	if (!url) throw new AIError("invalid_model", `Unsupported LoRA source: ${lora.id}`);
+	const root = imageLoRARoot().directory(id);
+	await root.create({ recursive: true });
+	const destination = root.file(safeCacheName(sourceFileName(resolvedDefinition), "lora filename"));
+	const expectedBytes = loraExpectedBytes(resolvedDefinition);
+	const stat = await destination.stat();
+	if (stat.type !== "file" || !hasSafetensorsHeader(stat.size) || expectedBytes !== void 0 && stat.size !== expectedBytes) await destination.download(url, {
+		headers: loraHeaders(resolvedDefinition, options.accessToken),
+		expectedBytes,
+		atomic: true,
+		resume: true,
+		signal: options.signal,
+		onProgress(progress) {
+			options.onProgress?.({
+				lora: lora.id,
+				file: destination.path,
+				bytesWritten: progress.bytesWritten,
+				totalBytes: progress.totalBytes,
+				fraction: progress.fraction
+			});
+		}
+	}).result;
+	await root.file("manifest.json").write(JSON.stringify({
+		formatVersion: 1,
+		id: lora.id,
+		file: destination.path.split("/").pop(),
+		source: resolvedDefinition.source,
+		metadata: lora.metadata
+	}, null, 2));
+	const preparedStat = await destination.stat();
+	if (preparedStat.type !== "file" || !hasSafetensorsHeader(preparedStat.size)) throw new AIError("invalid_model", `Invalid LoRA safetensors file: ${destination.path}`);
+	return {
+		id: lora.id,
+		description: lora.description,
+		path: destination.path,
+		uri: preparedStat.uri,
+		scale,
+		source: resolvedDefinition.source,
+		metadata: lora.metadata
+	};
+}
+async function verifyImageLoRA(lora) {
+	assertLoRADefinition(lora);
+	const scale = assertLoRAScale(lora.scale ?? lora.metadata?.recommendedScale);
+	let resolvedDefinition = lora;
+	if (lora.source.type === "huggingface" && !lora.source.path) {
+		const manifestFile = imageLoRARoot().directory(safeCacheName(lora.id, "lora.id")).file("manifest.json");
+		if ((await manifestFile.stat()).type === "file") {
+			const manifest = await manifestFile.json();
+			if (isRecord(manifest) && isRecord(manifest.source) && manifest.source.type === "huggingface" && manifest.source.repo === lora.source.repo && (manifest.source.revision ?? "main") === (lora.source.revision ?? "main") && typeof manifest.source.path === "string") resolvedDefinition = {
+				...lora,
+				source: {
+					...lora.source,
+					path: manifest.source.path,
+					revision: typeof manifest.source.revision === "string" ? manifest.source.revision : lora.source.revision,
+					bytes: typeof manifest.source.bytes === "number" ? manifest.source.bytes : lora.source.bytes
+				}
+			};
+		}
+	}
+	const file = resolvedDefinition.source.type === "local" ? files.file(filePathFromUri(resolvedDefinition.source.path, `lora ${lora.id}`)) : cachedLoRAFile(resolvedDefinition);
+	const stat = await file.stat();
+	const expectedBytes = loraExpectedBytes(resolvedDefinition);
+	const installed = stat.type === "file";
+	const verified = installed && hasSafetensorsHeader(stat.size) && (expectedBytes === void 0 || stat.size === expectedBytes);
+	return {
+		id: lora.id,
+		description: lora.description,
+		path: file.path,
+		uri: stat.uri,
+		scale,
+		source: resolvedDefinition.source,
+		metadata: lora.metadata,
+		installed,
+		verified,
+		size: stat.size
+	};
+}
+async function listImageLoRAs(loras) {
+	return Promise.all(loras.map((lora) => verifyImageLoRA(lora)));
+}
+async function deleteImageLoRA(lora) {
+	const id = safeCacheName(typeof lora === "string" ? lora : lora.id, "lora.id");
+	await imageLoRARoot().directory(id).delete({ recursive: true });
+}
+async function prepareSelectedImageLoRAs(loras, model, options = {}) {
+	const prepared = [];
+	for (const lora of loras) {
+		assertLoRADefinition(lora);
+		assertLoRACompatibility(lora, model);
+		prepared.push(await prepareImageLoRA(lora, options));
+	}
+	return prepared;
+}
+async function generateImage(options) {
+	throwIfAborted(options.signal);
+	const model = options.model ?? flux2Klein4B8BitAbliterated.model;
+	assertImageModel(model);
+	const prompt = options.prompt.trim();
+	if (!prompt) throw new AIError("invalid_message", "Expected prompt");
+	const presetSize = options.aspectRatio ? imageSizeForPreset(options.aspectRatio) : void 0;
+	const requestedSize = normalizeImageSize({
+		width: options.width ?? presetSize?.width ?? 1024,
+		height: options.height ?? presetSize?.height ?? 1024
+	}, false);
+	const width = requestedSize.width;
+	const height = requestedSize.height;
+	const outpaintSize = options.outpaint ? normalizeImageSize({
+		width: options.outpaint.width,
+		height: options.outpaint.height
+	}, false) : void 0;
+	if (options.outpaint && (outpaintSize?.width !== options.outpaint.width || outpaintSize?.height !== options.outpaint.height)) throw new AIError("invalid_model", "outpaint width and height must be multiples of 16");
+	const steps = options.steps ?? 4;
+	const guidance = options.guidance ?? 1;
+	const seed = options.seed ?? Math.floor(Math.random() * 4294967296);
+	const sourceImagePath = options.image ? filePathFromUri(options.image, "image") : void 0;
+	const maskImagePath = options.mask ? filePathFromUri(options.mask, "mask") : void 0;
+	const referenceImagePaths = (options.references ?? []).map((reference, index) => filePathFromUri(reference, `references[${index}]`));
+	const isImageConditioned = Boolean(sourceImagePath) || referenceImagePaths.length > 0;
+	const strength = options.strength ?? (isImageConditioned ? .8 : void 0);
+	if (maskImagePath && !sourceImagePath) throw new AIError("invalid_message", "mask requires image");
+	if (options.maskMode !== void 0 && options.maskMode !== "paint" && options.maskMode !== "preserve") throw new AIError("invalid_model", "maskMode must be paint or preserve");
+	if (options.outpaint && !sourceImagePath) throw new AIError("invalid_message", "outpaint requires image");
+	if (options.outpaint) {
+		assertPositiveInteger(options.outpaint.width, "outpaint.width");
+		assertPositiveInteger(options.outpaint.height, "outpaint.height");
+		const rect = options.outpaint.sourceRect;
+		if (!rect) throw new AIError("invalid_model", "outpaint.sourceRect is required");
+		assertPositiveInteger(rect.width, "outpaint.sourceRect.width");
+		assertPositiveInteger(rect.height, "outpaint.sourceRect.height");
+		if (!Number.isInteger(rect.x) || !Number.isInteger(rect.y)) throw new AIError("invalid_model", "outpaint.sourceRect x and y must be integers");
+		const canvasWidth = outpaintSize?.width ?? options.outpaint.width;
+		const canvasHeight = outpaintSize?.height ?? options.outpaint.height;
+		if (!(rect.x < canvasWidth && rect.y < canvasHeight && rect.x + rect.width > 0 && rect.y + rect.height > 0)) throw new AIError("invalid_model", "outpaint.sourceRect must intersect the canvas");
+		if (!options.outpaint.autoCrop && (rect.x < 0 || rect.y < 0 || rect.x + rect.width > canvasWidth || rect.y + rect.height > canvasHeight)) throw new AIError("invalid_model", "outpaint.sourceRect must fit within the outpaint canvas");
+	}
+	if (options.resizeMode !== void 0 && options.resizeMode !== "stretch" && options.resizeMode !== "fit" && options.resizeMode !== "crop") throw new AIError("invalid_model", "resizeMode must be stretch, fit, or crop");
+	if (options.maxInputLongSide !== void 0 && options.maxInputLongSide !== false && (!Number.isInteger(options.maxInputLongSide) || options.maxInputLongSide < 64)) throw new AIError("invalid_model", "maxInputLongSide must be false or an integer of at least 64");
+	assertPositiveInteger(width, "width");
+	assertPositiveInteger(height, "height");
+	assertPositiveInteger(steps, "steps");
+	if (seed !== void 0 && (!Number.isInteger(seed) || seed < 0)) throw new AIError("invalid_model", "seed must be a non-negative integer");
+	if (!Number.isFinite(guidance) || guidance <= 0) throw new AIError("invalid_model", "guidance must be a positive number");
+	if (referenceImagePaths.length > 3) throw new AIError("invalid_model", "references must contain at most 3 images");
+	if (options.referenceInfluences !== void 0) {
+		if (options.referenceInfluences.length !== referenceImagePaths.length) throw new AIError("invalid_model", "referenceInfluences must match references length");
+		for (const [index, influence] of options.referenceInfluences.entries()) if (!Number.isFinite(influence) || influence < 0) throw new AIError("invalid_model", `referenceInfluences[${index}] must be a non-negative number`);
+	}
+	if (strength !== void 0) assertUnitInterval(strength, "strength");
+	const selectedLoRAs = options.loras?.length ? await withImageStage("download", () => prepareSelectedImageLoRAs(options.loras ?? [], model, {
+		accessToken: options.accessToken,
+		signal: options.signal
+	})) : [];
+	const sigmaSchedule = imageSigmaSchedule(selectedLoRAs.map((lora) => lora.metadata?.sigmaSchedule));
+	if (sigmaSchedule && options.steps !== void 0 && options.steps !== sigmaSchedule.length) throw new AIError("invalid_model", `steps must equal the LoRA sigma schedule length (${sigmaSchedule.length})`);
+	const generationSteps = sigmaSchedule?.length ?? steps;
+	const prepared = options.modelRoot && options.tokenizer ? void 0 : await withImageStage("download", () => prepareImageModel({
+		model,
+		accessToken: options.accessToken,
+		concurrency: options.concurrency,
+		onProgress: options.onModelProgress
+	}));
+	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 tokenized = await withImageStage("tokenize", () => tokenizer({
+		prompt,
+		maxLength: 512
+	}));
+	throwIfAborted(options.signal);
+	await withImageStage("tokenize", () => {
+		assertTokenArray(tokenized.inputIds, "inputIds");
+		assertTokenArray(tokenized.attentionMask, "attentionMask");
+		if (tokenized.inputIds.length !== tokenized.attentionMask.length) throw new AIError("invalid_message", "inputIds and attentionMask must have the same length");
+	});
+	const paths = fluxImageModelPaths(modelRoot);
+	const request = {
+		model,
+		prompt,
+		sourceImagePath,
+		maskImagePath,
+		maskMode: options.maskMode,
+		outpaintWidth: outpaintSize?.width,
+		outpaintHeight: outpaintSize?.height,
+		outpaintSourceX: options.outpaint?.sourceRect.x,
+		outpaintSourceY: options.outpaint?.sourceRect.y,
+		outpaintSourceWidth: options.outpaint?.sourceRect.width,
+		outpaintSourceHeight: options.outpaint?.sourceRect.height,
+		outpaintAutoCrop: options.outpaint?.autoCrop,
+		resizeMode: options.resizeMode,
+		maxInputLongSide: options.maxInputLongSide === false ? 0 : options.maxInputLongSide ?? defaultImageLongSide,
+		referenceImagePaths,
+		referenceInfluences: options.referenceInfluences,
+		loraPaths: selectedLoRAs.map((lora) => lora.path),
+		loraScales: selectedLoRAs.map((lora) => lora.scale),
+		loraIds: selectedLoRAs.map((lora) => lora.id),
+		sigmaSchedule,
+		width,
+		height,
+		steps: generationSteps,
+		guidance,
+		strength,
+		seed,
+		inputIds: tokenized.inputIds,
+		attentionMask: tokenized.attentionMask,
+		...paths
+	};
+	const fallbackMetadata = {
+		model,
+		width: outpaintSize?.width ?? width,
+		height: outpaintSize?.height ?? height,
+		steps: generationSteps,
+		guidance,
+		strength,
+		seed,
+		appliedLoRAs: selectedLoRAs.map((lora) => ({
+			id: lora.id,
+			path: lora.path,
+			scale: lora.scale
+		})),
+		sigmaSchedule
+	};
+	try {
+		const native = bridge();
+		const cancelNative = () => {
+			native.cancelImagegen?.();
+		};
+		const subscription = options.onProgress ? native.addListener?.("imagegenProgress", (event) => {
+			const progress = imagegenProgress(event);
+			if (progress) options.onProgress?.(progress);
+		}) : void 0;
+		try {
+			options.signal?.addEventListener("abort", cancelNative, { once: true });
+			throwIfAborted(options.signal);
+			const value = await native.generateImage?.(request);
+			throwIfAborted(options.signal);
+			return imageResult(value, fallbackMetadata);
+		} finally {
+			subscription?.remove();
+			options.signal?.removeEventListener("abort", cancelNative);
+		}
+	} catch (error) {
+		if (error instanceof ImageGenerationError) throw error;
+		if (error instanceof AIError) throw error;
+		if (options.signal?.aborted) throw new AIError("generation_canceled", "Image generation canceled", error);
+		const mapped = mapNativeError(error);
+		if (mapped.code === "generation_failed" || mapped.code === "image_generation_failed") throw new ImageGenerationError(nativeErrorStage(error) ?? "denoise", nativeErrorMessage(error), error);
+		throw mapped;
+	}
+}
+async function generateImages(options) {
+	const { count,...imageOptions } = options;
+	const results = [];
+	for (const seed of batchImageSeeds(count, options.seed)) {
+		throwIfAborted(options.signal);
+		results.push(await generateImage({
+			...imageOptions,
+			seed
+		}));
+	}
+	return results;
+}
+const imageGenerationQueueKey = Symbol.for("bleam.ai.imageGenerationQueue");
+function imageGenerationQueue() {
+	const scope = globalThis;
+	const queue = scope[imageGenerationQueueKey] ?? new ImageGenerationQueue(generateImage);
+	queue.setExecutor(generateImage);
+	scope[imageGenerationQueueKey] = queue;
+	return queue;
+}
+function scheduleImageGeneration(options) {
+	return imageGenerationQueue().schedule(options);
+}
+function getImageGenerationJob(id) {
+	return imageGenerationQueue().get(id);
+}
+function listImageGenerationJobs() {
+	return imageGenerationQueue().list();
+}
+
+//#endregion
+//#region src/ai/image-composer.tsx
+const defaultImageSize = defaultImageLongSide;
+const defaultStepCount = 4;
+const minOutpaintScale = .35;
+const maxOutpaintScale = .95;
+function roundImageDimension(value) {
+	return normalizeImageSize({
+		width: value,
+		height: value
+	}, false).width;
+}
+function imageSizeForAspectRatio(size, maxSide = defaultImageSize) {
+	if (size.width <= 0 || size.height <= 0) return {
+		width: maxSide,
+		height: maxSide
+	};
+	const aspect = size.width / size.height;
+	return normalizeImageSize({
+		width: aspect >= 1 ? maxSide : maxSide * aspect,
+		height: aspect >= 1 ? maxSide / aspect : maxSide
+	}, maxSide);
+}
+function roundedImageSize(size) {
+	return normalizeImageSize(size);
+}
+function clamp(value, min$1, max) {
+	return Math.min(max, Math.max(min$1, value));
+}
+function clampOutpaintRect(rect) {
+	const width = Math.min(defaultImageSize, Math.max(1, Math.round(rect.width)));
+	const height = Math.min(defaultImageSize, Math.max(1, Math.round(rect.height)));
+	return {
+		x: Math.round(clamp(rect.x, 0, defaultImageSize - width)),
+		y: Math.round(clamp(rect.y, 0, defaultImageSize - height)),
+		width,
+		height
+	};
+}
+function rectForSourceScale(sourceSize, scale, center) {
+	const aspect = sourceSize.width / sourceSize.height;
+	const longSide = defaultImageSize * clamp(scale, minOutpaintScale, maxOutpaintScale);
+	const width = aspect >= 1 ? longSide : longSide * aspect;
+	const height = aspect >= 1 ? longSide / aspect : longSide;
+	const nextCenter = center ?? {
+		x: defaultImageSize / 2,
+		y: defaultImageSize / 2
+	};
+	return clampOutpaintRect({
+		x: nextCenter.x - width / 2,
+		y: nextCenter.y - height / 2,
+		width,
+		height
+	});
+}
+function initialOutpaintRect(sourceSize) {
+	return rectForSourceScale(sourceSize, .72);
+}
+function buildImageGenerationRequest(input, options = {}) {
+	const base = {
+		prompt: input.prompt,
+		mode: input.mode,
+		steps: defaultStepCount,
+		guidance: 1,
+		...options
+	};
+	if (input.mode === "text") {
+		const references = (input.refs ?? []).map((image) => image.path);
+		return {
+			...base,
+			references: references.length > 0 ? references : void 0,
+			referenceInfluences: references.length > 0 ? references.map(() => 1) : void 0,
+			strength: references.length > 0 ? 1 : void 0,
+			width: defaultImageSize,
+			height: defaultImageSize
+		};
+	}
+	if (input.mode === "subject") {
+		if (!input.subject) throw new Error("Subject mode requires a subject image");
+		const refs = input.refs ?? [];
+		const references = [input.subject, ...refs].map((image) => image.path);
+		const size = imageSizeForAspectRatio(input.subject.size);
+		return {
+			...base,
+			references,
+			referenceInfluences: references.map(() => 1),
+			strength: 1,
+			width: size.width,
+			height: size.height
+		};
+	}
+	if (input.mode === "edit") {
+		if (!input.source) throw new Error("Edit requires a source image");
+		const references = (input.refs ?? []).map((image) => image.path);
+		const size = roundedImageSize(input.source.size);
+		return {
+			...base,
+			image: input.source.path,
+			references: references.length > 0 ? references : void 0,
+			referenceInfluences: references.length > 0 ? references.map(() => 1) : void 0,
+			strength: references.length > 0 ? 1 : .35,
+			width: size.width,
+			height: size.height
+		};
+	}
+	if (!input.source) throw new Error("Outpaint requires a source image");
+	if (!input.rect) throw new Error("Outpaint requires a source placement");
+	return {
+		...base,
+		image: input.source.path,
+		outpaint: {
+			width: defaultImageSize,
+			height: defaultImageSize,
+			sourceRect: input.rect,
+			autoCrop: true
+		},
+		strength: .8,
+		width: defaultImageSize,
+		height: defaultImageSize
+	};
+}
+function useImageComposer(modeOrOptions, options = {}) {
+	if (typeof modeOrOptions !== "string") return useImageComposerController(modeOrOptions ?? {});
+	const mode = modeOrOptions;
+	if (mode === "text") return useTextComposer(options);
+	if (mode === "subject") return useSubjectComposer(options);
+	if (mode === "edit") return useEditComposer(options);
+	return useOutpaintComposer(options);
+}
+function useImageComposerController(options) {
+	const [mode, setMode] = useAtom(useComposerAtom(options.initialMode ?? "text"));
+	const text = useTextComposer(options);
+	const subject = useSubjectComposer(options);
+	const edit = useEditComposer(options);
+	const outpaint = useOutpaintComposer(options);
+	const active = mode === "text" ? text : mode === "subject" ? subject : mode === "edit" ? edit : outpaint;
+	const error = active.error ?? text.error ?? subject.error ?? edit.error ?? outpaint.error;
+	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] = 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] = 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] = 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] = 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] = 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] = 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 ??= atom(initialValue);
+	return ref.current;
+}
+function useStableRef(initialValue) {
+	return useRef(initialValue);
+}
+function removeRefFromState(state, index) {
+	return {
+		...state,
+		refs: state.refs.filter((_, i) => i !== index)
+	};
+}
+function inputDestination(inputRoot) {
+	return files.directory(inputRoot ?? files.paths.shared, "ImageGenerationInputs", String(Date.now()));
+}
+async function pickOneImage(inputRoot) {
+	const [picked] = await files.pick({
+		type: "image",
+		destination: inputDestination(inputRoot)
+	});
+	if (!picked) return null;
+	return Object.assign(picked, { size: await getImageSize(picked.uri) });
+}
+async function pickImages(inputRoot) {
+	const picked = await files.pick({
+		type: "image",
+		multiple: true,
+		destination: inputDestination(inputRoot)
+	});
+	return Promise.all(picked.map(async (image) => Object.assign(image, { size: await getImageSize(image.uri) })));
+}
+function getImageSize(uri) {
+	return new Promise((resolve, reject) => {
+		Image.getSize(uri, (width, height) => resolve({
+			width,
+			height
+		}), reject);
+	});
+}
+function errorFromUnknown(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+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);
@@ -17,9 +3777,6 @@ var ShapeError = class extends Error {
 		this.name = "ShapeError";
 	}
 };
-function isRecord(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
 function issue(message, path = []) {
 	return {
 		message,
@@ -113,6 +3870,7 @@ function shape(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);
@@ -124,6 +3882,9 @@ function stableStringify(value) {
 	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);
@@ -132,21 +3893,6 @@ function promptFromInput(options) {
 	if (parts.length === 0) throw new AIError("invalid_message", "Expected prompt or input");
 	return parts.join("\n\n");
 }
-function bridge() {
-	const nativeBridge = NativeModules.BleamAIBridge;
-	if (!nativeBridge) throw new AIError("unsupported_runtime", "bleam/ai requires the Bleam native runtime");
-	return nativeBridge;
-}
-function mapNativeError(error) {
-	const code = isRecord(error) && typeof error.code === "string" ? error.code : "";
-	const message = error instanceof Error ? error.message : String(error);
-	if (code === "UNSUPPORTED_OS") return new AIError("unsupported_os", message, error);
-	if (code === "MODEL_UNAVAILABLE") return new AIError("model_unavailable", message, error);
-	if (code === "INVALID_SCHEMA") return new AIError("invalid_schema", message, error);
-	if (code === "INVALID_MESSAGE") return new AIError("invalid_message", message, error);
-	if (code === "CONTEXT_WINDOW_EXCEEDED") return new AIError("context_window_exceeded", message, error);
-	return new AIError("generation_failed", message, error);
-}
 async function isAvailable() {
 	try {
 		return await bridge().isAvailable?.() ?? false;
@@ -154,17 +3900,82 @@ async function isAvailable() {
 		return false;
 	}
 }
-async function generate(options) {
-	const output = options.output;
-	const request = {
+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: output ? schemaToBridgeSchema(output) : void 0
+		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 {
-		const value = await bridge().generate?.(request);
+		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);
@@ -175,8 +3986,117 @@ async function generate(options) {
 	} 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] = useState(initialState);
+	const abortControllerRef = useRef(null);
+	async function run(options) {
+		if (abortControllerRef.current) return null;
+		const abortController = new AbortController();
+		const abort = () => abortController.abort();
+		abortControllerRef.current = abortController;
+		options.signal?.addEventListener("abort", abort, { once: true });
+		if (options.signal?.aborted) abortController.abort();
+		setState({
+			text: "",
+			isGenerating: true,
+			error: null
+		});
+		let text = "";
+		try {
+			for await (const snapshot of stream({
+				...options,
+				signal: abortController.signal
+			})) {
+				text = snapshot;
+				setState({
+					text,
+					isGenerating: true,
+					error: null
+				});
+			}
+			setState({
+				text,
+				isGenerating: false,
+				error: null
+			});
+			return text;
+		} catch (error) {
+			setState({
+				text,
+				isGenerating: false,
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+			return null;
+		} finally {
+			options.signal?.removeEventListener("abort", abort);
+			if (abortControllerRef.current === abortController) abortControllerRef.current = null;
+		}
 	}
+	function cancel() {
+		abortControllerRef.current?.abort();
+	}
+	function clear() {
+		if (abortControllerRef.current) return;
+		setState(initialState);
+	}
+	return {
+		...state,
+		run,
+		cancel,
+		clear
+	};
 }
 
 //#endregion
-export { AIError, generate, isAvailable, shape };
+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 };