@happyvertical/smrt-images 0.37.1 → 0.37.3

package/dist/index.js

@@ -1,18 +1,18 @@
-import { ObjectRegistry, field, smrt, SmrtCollection } from "@happyvertical/smrt-core";
+import { ObjectRegistry, SmrtCollection, field, smrt } from "@happyvertical/smrt-core";
 import { definePrompt, resolvePrompt } from "@happyvertical/smrt-prompts";
 import { randomUUID } from "node:crypto";
-import { writeFile, readFile, unlink } from "node:fs/promises";
+import { readFile, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { Asset } from "@happyvertical/smrt-assets";
-import { persistMediaBundleInspection } from "@happyvertical/smrt-assets";
-import { TenantScoped, getCurrentTenant, isSuperAdminBypass, TenantIsolationError } from "@happyvertical/smrt-tenancy";
-ObjectRegistry.registerPackageManifest(
-  new URL("./manifest.json", import.meta.url)
-);
-const smrtImagesGenerateAltTextPrompt = definePrompt({
-  key: "smrtImages.image.generateAltText",
-  template: `Generate concise accessibility alt text for this image.
+import { Asset, persistMediaBundleInspection as persistImageMediaBundleInspection } from "@happyvertical/smrt-assets";
+import { TenantIsolationError, TenantScoped, getCurrentTenant, isSuperAdminBypass } from "@happyvertical/smrt-tenancy";
+//#region src/__smrt-register__.ts
+ObjectRegistry.registerPackageManifest(new URL("./manifest.json", "" + import.meta.url));
+//#endregion
+//#region src/prompts.ts
+var smrtImagesGenerateAltTextPrompt = definePrompt({
+	key: "smrtImages.image.generateAltText",
+	template: `Generate concise accessibility alt text for this image.
 Consider: subject matter, key visual elements, context.
 Keep it under 125 characters for screen reader compatibility.
 
@@ -20,77 +20,71 @@ Image name: {imageName}
 Image description: {imageDescription}
 
 Return only the alt text, with no commentary or surrounding quotation marks.`,
-  editable: {
-    template: true,
-    profile: true,
-    model: true,
-    params: true
-  }
+	editable: {
+		template: true,
+		profile: true,
+		model: true,
+		params: true
+	}
 });
 function promptMessageOptions(ai) {
-  return {
-    ...ai.params || {},
-    ...ai.model ? { model: ai.model } : {},
-    ...typeof ai.temperature === "number" ? { temperature: ai.temperature } : {},
-    ...typeof ai.maxTokens === "number" ? { maxTokens: ai.maxTokens } : {}
-  };
+	return {
+		...ai.params || {},
+		...ai.model ? { model: ai.model } : {},
+		...typeof ai.temperature === "number" ? { temperature: ai.temperature } : {},
+		...typeof ai.maxTokens === "number" ? { maxTokens: ai.maxTokens } : {}
+	};
 }
+//#endregion
+//#region src/categorizer.ts
 function extractFirstJsonObject(text) {
-  const start = text.indexOf("{");
-  if (start === -1) return null;
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
-    if (inString) {
-      if (escaped) {
-        escaped = false;
-      } else if (ch === "\\") {
-        escaped = true;
-      } else if (ch === '"') {
-        inString = false;
-      }
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-    } else if (ch === "{") {
-      depth++;
-    } else if (ch === "}") {
-      depth--;
-      if (depth === 0) {
-        return text.slice(start, i + 1);
-      }
-    }
-  }
-  return null;
+	const start = text.indexOf("{");
+	if (start === -1) return null;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let i = start; i < text.length; i++) {
+		const ch = text[i];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") inString = true;
+		else if (ch === "{") depth++;
+		else if (ch === "}") {
+			depth--;
+			if (depth === 0) return text.slice(start, i + 1);
+		}
+	}
+	return null;
 }
 function normalizeCategoryResult(parsed, fallbackDescription) {
-  const p = parsed ?? {};
-  return {
-    tags: Array.isArray(p.tags) ? p.tags : [],
-    description: typeof p.description === "string" && p.description ? p.description : fallbackDescription,
-    confidence: typeof p.confidence === "number" ? p.confidence : 0,
-    subjects: Array.isArray(p.subjects) ? p.subjects : []
-  };
+	const p = parsed ?? {};
+	return {
+		tags: Array.isArray(p.tags) ? p.tags : [],
+		description: typeof p.description === "string" && p.description ? p.description : fallbackDescription,
+		confidence: typeof p.confidence === "number" ? p.confidence : 0,
+		subjects: Array.isArray(p.subjects) ? p.subjects : []
+	};
 }
-class ImageCategorizer {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  /**
-   * Categorize an image using AI vision analysis
-   *
-   * @param image - The Image instance to categorize
-   * @param buffer - Optional raw image data for vision analysis
-   * @returns Categorization results with tags, description, and subjects
-   */
-  async categorize(image, buffer) {
-    const { getAI } = await import("@happyvertical/ai");
-    const ai = await getAI(this.options.ai);
-    const prompt = `Analyze this image and provide categorization.
+var ImageCategorizer = class {
+	constructor(options) {
+		this.options = options;
+	}
+	options;
+	/**
+	* Categorize an image using AI vision analysis
+	*
+	* @param image - The Image instance to categorize
+	* @param buffer - Optional raw image data for vision analysis
+	* @returns Categorization results with tags, description, and subjects
+	*/
+	async categorize(image, buffer) {
+		const { getAI } = await import("@happyvertical/ai");
+		const ai = await getAI(this.options.ai);
+		const prompt = `Analyze this image and provide categorization.
 Image name: ${image.name}
 Image description: ${image.description}
 MIME type: ${image.mimeType}
@@ -103,793 +97,694 @@ Respond in JSON format:
   "confidence": 0.0-1.0,
   "subjects": ["subject1", "subject2", ...]
 }`;
-    const response = await ai.chat([{ role: "user", content: prompt }]);
-    const text = response.content;
-    const fallbackDescription = image.description || image.name;
-    const jsonText = extractFirstJsonObject(text);
-    if (jsonText) {
-      try {
-        return normalizeCategoryResult(
-          JSON.parse(jsonText),
-          fallbackDescription
-        );
-      } catch {
-      }
-    }
-    return {
-      tags: [],
-      description: fallbackDescription,
-      confidence: 0,
-      subjects: []
-    };
-  }
-  /**
-   * Run categorization and apply results to the image
-   *
-   * @param image - The Image to categorize and update
-   * @param assetCollection - AssetCollection for tag management
-   */
-  async autoTag(image, assetCollection) {
-    const result = await this.categorize(image);
-    if (result.description && !image.description) {
-      image.description = result.description;
-    }
-    if (!image.alt && result.description) {
-      image.alt = result.description.slice(0, 125);
-    }
-    await image.save();
-    for (const tag of result.tags ?? []) {
-      await assetCollection.addTag(image.id, tag);
-    }
-  }
-}
-class ImageDeriver {
-  constructor(store, collection, options) {
-    this.store = store;
-    this.collection = collection;
-    this.options = options;
-  }
-  store;
-  collection;
-  options;
-  /**
-   * Derive new images from source images and a creative prompt
-   *
-   * @param sources - One or more source images
-   * @param prompt - Creative instructions for generation
-   * @param deriveOptions - Generation options (count, size, style)
-   * @returns Array of newly created derivative Images
-   */
-  async derive(sources, prompt, deriveOptions = {}) {
-    if (sources.length === 0) {
-      throw new Error("At least one source image is required");
-    }
-    const { getAI } = await import("@happyvertical/ai");
-    const ai = await getAI(this.options.ai);
-    const count = deriveOptions.count ?? 1;
-    const results = [];
-    const fullPrompt = [
-      prompt,
-      deriveOptions.style ? `Style: ${deriveOptions.style}` : "",
-      deriveOptions.size ? `Output size: ${deriveOptions.size}` : "",
-      `Source images: ${sources.map((s) => s.name).join(", ")}`
-    ].filter(Boolean).join("\n");
-    for (let i = 0; i < count; i++) {
-      const response = await ai.generateImage(fullPrompt, {
-        size: deriveOptions.size
-      });
-      const imageData = response.images[0]?.data;
-      if (!imageData || !(imageData instanceof Buffer)) {
-        throw new Error("AI did not return image data as Buffer");
-      }
-      const result = imageData;
-      const derived = await this.collection.create({
-        name: `derived-${sources[0].name}-${i + 1}`,
-        mimeType: "image/png",
-        sourceUri: "",
-        sourceAssetId: sources[0].id,
-        typeSlug: "image",
-        description: `Derived: ${prompt}`
-      });
-      const sourceUri = await this.store.storeFile(derived, result, {
-        mimeType: "image/png",
-        typeSlug: "image"
-      });
-      derived.sourceUri = sourceUri;
-      await derived.save();
-      results.push(derived);
-    }
-    return results;
-  }
-  /**
-   * Derive images and link all sources via AssetAssociation
-   *
-   * @param sources - Source images
-   * @param prompt - Creative instructions
-   * @param associations - AssetAssociationCollection for linking
-   * @param deriveOptions - Generation options
-   * @returns Array of newly created derivative Images
-   */
-  async deriveWithAssociations(sources, prompt, associations, deriveOptions = {}) {
-    const results = await this.derive(sources, prompt, deriveOptions);
-    for (const derived of results) {
-      for (const source of sources) {
-        await associations.attach("Image", derived.id, source.id, {
-          role: "derivation-source"
-        });
-      }
-    }
-    return results;
-  }
-}
-const ALLOWED_CONVERT_FORMATS = /* @__PURE__ */ new Set([
-  "jpeg",
-  "png",
-  "webp",
-  "avif",
-  "gif",
-  "tiff"
+		const text = (await ai.chat([{
+			role: "user",
+			content: prompt
+		}])).content;
+		const fallbackDescription = image.description || image.name;
+		const jsonText = extractFirstJsonObject(text);
+		if (jsonText) try {
+			return normalizeCategoryResult(JSON.parse(jsonText), fallbackDescription);
+		} catch {}
+		return {
+			tags: [],
+			description: fallbackDescription,
+			confidence: 0,
+			subjects: []
+		};
+	}
+	/**
+	* Run categorization and apply results to the image
+	*
+	* @param image - The Image to categorize and update
+	* @param assetCollection - AssetCollection for tag management
+	*/
+	async autoTag(image, assetCollection) {
+		const result = await this.categorize(image);
+		if (result.description && !image.description) image.description = result.description;
+		if (!image.alt && result.description) image.alt = result.description.slice(0, 125);
+		await image.save();
+		for (const tag of result.tags ?? []) await assetCollection.addTag(image.id, tag);
+	}
+};
+//#endregion
+//#region src/deriver.ts
+var ImageDeriver = class {
+	constructor(store, collection, options) {
+		this.store = store;
+		this.collection = collection;
+		this.options = options;
+	}
+	store;
+	collection;
+	options;
+	/**
+	* Derive new images from source images and a creative prompt
+	*
+	* @param sources - One or more source images
+	* @param prompt - Creative instructions for generation
+	* @param deriveOptions - Generation options (count, size, style)
+	* @returns Array of newly created derivative Images
+	*/
+	async derive(sources, prompt, deriveOptions = {}) {
+		if (sources.length === 0) throw new Error("At least one source image is required");
+		const { getAI } = await import("@happyvertical/ai");
+		const ai = await getAI(this.options.ai);
+		const count = deriveOptions.count ?? 1;
+		const results = [];
+		const fullPrompt = [
+			prompt,
+			deriveOptions.style ? `Style: ${deriveOptions.style}` : "",
+			deriveOptions.size ? `Output size: ${deriveOptions.size}` : "",
+			`Source images: ${sources.map((s) => s.name).join(", ")}`
+		].filter(Boolean).join("\n");
+		for (let i = 0; i < count; i++) {
+			const imageData = (await ai.generateImage(fullPrompt, { size: deriveOptions.size })).images[0]?.data;
+			if (!imageData || !(imageData instanceof Buffer)) throw new Error("AI did not return image data as Buffer");
+			const result = imageData;
+			const derived = await this.collection.create({
+				name: `derived-${sources[0].name}-${i + 1}`,
+				mimeType: "image/png",
+				sourceUri: "",
+				sourceAssetId: sources[0].id,
+				typeSlug: "image",
+				description: `Derived: ${prompt}`
+			});
+			derived.sourceUri = await this.store.storeFile(derived, result, {
+				mimeType: "image/png",
+				typeSlug: "image"
+			});
+			await derived.save();
+			results.push(derived);
+		}
+		return results;
+	}
+	/**
+	* Derive images and link all sources via AssetAssociation
+	*
+	* @param sources - Source images
+	* @param prompt - Creative instructions
+	* @param associations - AssetAssociationCollection for linking
+	* @param deriveOptions - Generation options
+	* @returns Array of newly created derivative Images
+	*/
+	async deriveWithAssociations(sources, prompt, associations, deriveOptions = {}) {
+		const results = await this.derive(sources, prompt, deriveOptions);
+		for (const derived of results) for (const source of sources) await associations.attach("Image", derived.id, source.id, { role: "derivation-source" });
+		return results;
+	}
+};
+//#endregion
+//#region src/editor.ts
+var ALLOWED_CONVERT_FORMATS = /* @__PURE__ */ new Set([
+	"jpeg",
+	"png",
+	"webp",
+	"avif",
+	"gif",
+	"tiff"
 ]);
-class ImageEditor {
-  constructor(store, collection, options = {}) {
-    this.store = store;
-    this.collection = collection;
-    this.options = options;
-  }
-  store;
-  collection;
-  options;
-  /**
-   * Resize an image to the specified dimensions
-   *
-   * @param image - Source image
-   * @param width - Target width
-   * @param height - Target height
-   * @returns New derivative Image
-   */
-  async resize(image, width, height) {
-    const { resizeImage } = await import("@happyvertical/images");
-    const sourceData = await this.store.read(image);
-    const inputPath = join(tmpdir(), `smrt-edit-in-${randomUUID()}.bin`);
-    const outputPath = join(tmpdir(), `smrt-edit-out-${randomUUID()}.bin`);
-    try {
-      await writeFile(inputPath, sourceData);
-      await resizeImage(inputPath, outputPath, { width, height });
-      const resized = await readFile(outputPath);
-      return this.createDerivative(image, resized, {
-        name: `${image.name}-${width}x${height}`,
-        width,
-        height,
-        description: `Resized from ${image.width}x${image.height} to ${width}x${height}`
-      });
-    } finally {
-      await unlink(inputPath).catch(() => {
-      });
-      await unlink(outputPath).catch(() => {
-      });
-    }
-  }
-  /**
-   * Crop an image to the specified region
-   *
-   * @param image - Source image
-   * @param x - Left offset
-   * @param y - Top offset
-   * @param w - Crop width
-   * @param h - Crop height
-   * @returns New derivative Image
-   */
-  async crop(image, x, y, w, h) {
-    const { getImageProcessor } = await import("@happyvertical/images");
-    const processor = await getImageProcessor();
-    const sourceData = await this.store.read(image);
-    const inputPath = join(tmpdir(), `smrt-crop-in-${randomUUID()}.bin`);
-    const outputPath = join(tmpdir(), `smrt-crop-out-${randomUUID()}.bin`);
-    try {
-      await writeFile(inputPath, sourceData);
-      await processor.resize(inputPath, outputPath, {
-        width: w,
-        height: h,
-        fit: "cover"
-      });
-      const cropped = await readFile(outputPath);
-      return this.createDerivative(image, cropped, {
-        name: `${image.name}-crop`,
-        width: w,
-        height: h,
-        description: `Cropped region ${x},${y} ${w}x${h}`
-      });
-    } finally {
-      await unlink(inputPath).catch(() => {
-      });
-      await unlink(outputPath).catch(() => {
-      });
-    }
-  }
-  /**
-   * Convert an image to a different format
-   *
-   * @param image - Source image
-   * @param format - Target format (e.g., 'webp', 'png', 'jpeg')
-   * @returns New derivative Image
-   */
-  async convert(image, format) {
-    const normalizedFormat = format.trim().toLowerCase();
-    if (!ALLOWED_CONVERT_FORMATS.has(normalizedFormat)) {
-      throw new Error(
-        `Unsupported image format: ${JSON.stringify(format)}. Allowed formats: ${[...ALLOWED_CONVERT_FORMATS].join(", ")}`
-      );
-    }
-    const safeFormat = normalizedFormat;
-    const { convertFormat } = await import("@happyvertical/images");
-    const sourceData = await this.store.read(image);
-    const mimeType = `image/${safeFormat}`;
-    const inputPath = join(tmpdir(), `smrt-conv-in-${randomUUID()}.bin`);
-    const outputPath = join(
-      tmpdir(),
-      `smrt-conv-out-${randomUUID()}.${safeFormat}`
-    );
-    try {
-      await writeFile(inputPath, sourceData);
-      await convertFormat(inputPath, outputPath, {
-        format: safeFormat
-      });
-      const converted = await readFile(outputPath);
-      return this.createDerivative(image, converted, {
-        name: `${image.name}.${safeFormat}`,
-        mimeType,
-        description: `Converted from ${image.mimeType} to ${mimeType}`
-      });
-    } finally {
-      await unlink(inputPath).catch(() => {
-      });
-      await unlink(outputPath).catch(() => {
-      });
-    }
-  }
-  /**
-   * Generate a square thumbnail of the specified size
-   *
-   * @param image - Source image
-   * @param size - Thumbnail dimension (square)
-   * @returns New derivative Image
-   */
-  async thumbnail(image, size) {
-    const { generateThumbnail } = await import("@happyvertical/images");
-    const sourceData = await this.store.read(image);
-    const inputPath = join(tmpdir(), `smrt-thumb-in-${randomUUID()}.bin`);
-    const outputPath = join(tmpdir(), `smrt-thumb-out-${randomUUID()}.bin`);
-    try {
-      await writeFile(inputPath, sourceData);
-      await generateThumbnail(inputPath, outputPath, {
-        maxWidth: size,
-        maxHeight: size
-      });
-      const thumbData = await readFile(outputPath);
-      return this.createDerivative(image, thumbData, {
-        name: `${image.name}-thumb-${size}`,
-        width: size,
-        height: size,
-        description: `Thumbnail ${size}x${size}`
-      });
-    } finally {
-      await unlink(inputPath).catch(() => {
-      });
-      await unlink(outputPath).catch(() => {
-      });
-    }
-  }
-  /**
-   * AI-powered image generation based on a prompt (creates derivative linked to source)
-   *
-   * @param image - Source image (used for metadata, linked as parent)
-   * @param prompt - Generation instructions (e.g., "similar image with sunset colors")
-   * @returns New derivative Image
-   */
-  async edit(image, prompt) {
-    if (!this.options.ai) {
-      throw new Error("AI options required for AI-powered editing");
-    }
-    const { getAI } = await import("@happyvertical/ai");
-    const ai = await getAI(this.options.ai);
-    const response = await ai.generateImage(prompt, {
-      size: `${image.width}x${image.height}`
-    });
-    const imageData = response.images[0]?.data;
-    if (!imageData || !(imageData instanceof Buffer)) {
-      throw new Error("AI did not return image data as Buffer");
-    }
-    return this.createDerivative(image, imageData, {
-      name: `${image.name}-edited`,
-      description: `AI edit: ${prompt}`
-    });
-  }
-  /**
-   * Generate variations of an image using AI
-   *
-   * @param image - Source image
-   * @param prompt - Variation instructions
-   * @param options - Number of variations to generate
-   * @returns Array of new derivative Images
-   */
-  async generateVariation(image, prompt, options = {}) {
-    const count = options.count ?? 1;
-    const results = [];
-    for (let i = 0; i < count; i++) {
-      const variation = await this.edit(
-        image,
-        `${prompt} (variation ${i + 1} of ${count})`
-      );
-      results.push(variation);
-    }
-    return results;
-  }
-  /**
-   * Helper: Create a derivative Image from processed buffer data
-   */
-  async createDerivative(source, data, overrides) {
-    const mimeType = overrides.mimeType ?? source.mimeType;
-    const typeSlug = source.typeSlug || "image";
-    const derivative = await this.collection.create({
-      name: overrides.name,
-      sourceUri: "",
-      mimeType,
-      width: overrides.width ?? source.width,
-      height: overrides.height ?? source.height,
-      alt: source.alt,
-      sourceAssetId: source.id,
-      typeSlug,
-      description: overrides.description ?? ""
-    });
-    const sourceUri = await this.store.storeFile(derivative, data, {
-      mimeType,
-      typeSlug
-    });
-    derivative.sourceUri = sourceUri;
-    await derivative.save();
-    return derivative;
-  }
-}
+var ImageEditor = class {
+	constructor(store, collection, options = {}) {
+		this.store = store;
+		this.collection = collection;
+		this.options = options;
+	}
+	store;
+	collection;
+	options;
+	/**
+	* Resize an image to the specified dimensions
+	*
+	* @param image - Source image
+	* @param width - Target width
+	* @param height - Target height
+	* @returns New derivative Image
+	*/
+	async resize(image, width, height) {
+		const { resizeImage } = await import("@happyvertical/images");
+		const sourceData = await this.store.read(image);
+		const inputPath = join(tmpdir(), `smrt-edit-in-${randomUUID()}.bin`);
+		const outputPath = join(tmpdir(), `smrt-edit-out-${randomUUID()}.bin`);
+		try {
+			await writeFile(inputPath, sourceData);
+			await resizeImage(inputPath, outputPath, {
+				width,
+				height
+			});
+			const resized = await readFile(outputPath);
+			return this.createDerivative(image, resized, {
+				name: `${image.name}-${width}x${height}`,
+				width,
+				height,
+				description: `Resized from ${image.width}x${image.height} to ${width}x${height}`
+			});
+		} finally {
+			await unlink(inputPath).catch(() => {});
+			await unlink(outputPath).catch(() => {});
+		}
+	}
+	/**
+	* Crop an image to the specified region
+	*
+	* @param image - Source image
+	* @param x - Left offset
+	* @param y - Top offset
+	* @param w - Crop width
+	* @param h - Crop height
+	* @returns New derivative Image
+	*/
+	async crop(image, x, y, w, h) {
+		const { getImageProcessor } = await import("@happyvertical/images");
+		const processor = await getImageProcessor();
+		const sourceData = await this.store.read(image);
+		const inputPath = join(tmpdir(), `smrt-crop-in-${randomUUID()}.bin`);
+		const outputPath = join(tmpdir(), `smrt-crop-out-${randomUUID()}.bin`);
+		try {
+			await writeFile(inputPath, sourceData);
+			await processor.resize(inputPath, outputPath, {
+				width: w,
+				height: h,
+				fit: "cover"
+			});
+			const cropped = await readFile(outputPath);
+			return this.createDerivative(image, cropped, {
+				name: `${image.name}-crop`,
+				width: w,
+				height: h,
+				description: `Cropped region ${x},${y} ${w}x${h}`
+			});
+		} finally {
+			await unlink(inputPath).catch(() => {});
+			await unlink(outputPath).catch(() => {});
+		}
+	}
+	/**
+	* Convert an image to a different format
+	*
+	* @param image - Source image
+	* @param format - Target format (e.g., 'webp', 'png', 'jpeg')
+	* @returns New derivative Image
+	*/
+	async convert(image, format) {
+		const normalizedFormat = format.trim().toLowerCase();
+		if (!ALLOWED_CONVERT_FORMATS.has(normalizedFormat)) throw new Error(`Unsupported image format: ${JSON.stringify(format)}. Allowed formats: ${[...ALLOWED_CONVERT_FORMATS].join(", ")}`);
+		const safeFormat = normalizedFormat;
+		const { convertFormat } = await import("@happyvertical/images");
+		const sourceData = await this.store.read(image);
+		const mimeType = `image/${safeFormat}`;
+		const inputPath = join(tmpdir(), `smrt-conv-in-${randomUUID()}.bin`);
+		const outputPath = join(tmpdir(), `smrt-conv-out-${randomUUID()}.${safeFormat}`);
+		try {
+			await writeFile(inputPath, sourceData);
+			await convertFormat(inputPath, outputPath, { format: safeFormat });
+			const converted = await readFile(outputPath);
+			return this.createDerivative(image, converted, {
+				name: `${image.name}.${safeFormat}`,
+				mimeType,
+				description: `Converted from ${image.mimeType} to ${mimeType}`
+			});
+		} finally {
+			await unlink(inputPath).catch(() => {});
+			await unlink(outputPath).catch(() => {});
+		}
+	}
+	/**
+	* Generate a square thumbnail of the specified size
+	*
+	* @param image - Source image
+	* @param size - Thumbnail dimension (square)
+	* @returns New derivative Image
+	*/
+	async thumbnail(image, size) {
+		const { generateThumbnail } = await import("@happyvertical/images");
+		const sourceData = await this.store.read(image);
+		const inputPath = join(tmpdir(), `smrt-thumb-in-${randomUUID()}.bin`);
+		const outputPath = join(tmpdir(), `smrt-thumb-out-${randomUUID()}.bin`);
+		try {
+			await writeFile(inputPath, sourceData);
+			await generateThumbnail(inputPath, outputPath, {
+				maxWidth: size,
+				maxHeight: size
+			});
+			const thumbData = await readFile(outputPath);
+			return this.createDerivative(image, thumbData, {
+				name: `${image.name}-thumb-${size}`,
+				width: size,
+				height: size,
+				description: `Thumbnail ${size}x${size}`
+			});
+		} finally {
+			await unlink(inputPath).catch(() => {});
+			await unlink(outputPath).catch(() => {});
+		}
+	}
+	/**
+	* AI-powered image generation based on a prompt (creates derivative linked to source)
+	*
+	* @param image - Source image (used for metadata, linked as parent)
+	* @param prompt - Generation instructions (e.g., "similar image with sunset colors")
+	* @returns New derivative Image
+	*/
+	async edit(image, prompt) {
+		if (!this.options.ai) throw new Error("AI options required for AI-powered editing");
+		const { getAI } = await import("@happyvertical/ai");
+		const imageData = (await (await getAI(this.options.ai)).generateImage(prompt, { size: `${image.width}x${image.height}` })).images[0]?.data;
+		if (!imageData || !(imageData instanceof Buffer)) throw new Error("AI did not return image data as Buffer");
+		return this.createDerivative(image, imageData, {
+			name: `${image.name}-edited`,
+			description: `AI edit: ${prompt}`
+		});
+	}
+	/**
+	* Generate variations of an image using AI
+	*
+	* @param image - Source image
+	* @param prompt - Variation instructions
+	* @param options - Number of variations to generate
+	* @returns Array of new derivative Images
+	*/
+	async generateVariation(image, prompt, options = {}) {
+		const count = options.count ?? 1;
+		const results = [];
+		for (let i = 0; i < count; i++) {
+			const variation = await this.edit(image, `${prompt} (variation ${i + 1} of ${count})`);
+			results.push(variation);
+		}
+		return results;
+	}
+	/**
+	* Helper: Create a derivative Image from processed buffer data
+	*/
+	async createDerivative(source, data, overrides) {
+		const mimeType = overrides.mimeType ?? source.mimeType;
+		const typeSlug = source.typeSlug || "image";
+		const derivative = await this.collection.create({
+			name: overrides.name,
+			sourceUri: "",
+			mimeType,
+			width: overrides.width ?? source.width,
+			height: overrides.height ?? source.height,
+			alt: source.alt,
+			sourceAssetId: source.id,
+			typeSlug,
+			description: overrides.description ?? ""
+		});
+		derivative.sourceUri = await this.store.storeFile(derivative, data, {
+			mimeType,
+			typeSlug
+		});
+		await derivative.save();
+		return derivative;
+	}
+};
+//#endregion
+//#region src/image.ts
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
 };
-let Image = class extends Asset {
-  width = 0;
-  height = 0;
-  alt = "";
-  constructor(options = {}) {
-    super(options);
-    if (options.width !== void 0) this.width = options.width;
-    if (options.height !== void 0) this.height = options.height;
-    if (options.alt !== void 0) this.alt = options.alt;
-  }
-  /**
-   * Calculate aspect ratio from dimensions
-   */
-  get aspectRatio() {
-    if (this.height === 0) return 0;
-    return this.width / this.height;
-  }
-  /**
-   * Helper to get URL from sourceUri for frontend components
-   */
-  get url() {
-    return this.sourceUri;
-  }
-  /**
-   * Check if dimensions indicate landscape orientation
-   */
-  get isLandscape() {
-    return this.width > this.height;
-  }
-  /**
-   * Check if dimensions indicate portrait orientation
-   */
-  get isPortrait() {
-    return this.height > this.width;
-  }
-  /**
-   * Check if dimensions indicate square aspect ratio
-   */
-  get isSquare() {
-    return this.width === this.height && this.width > 0;
-  }
-  /**
-   * Validate that the asset is an image based on MIME type
-   */
-  isValidImageFormat() {
-    return this.mimeType.startsWith("image/");
-  }
-  /**
-   * Check if this image is high resolution (4K+)
-   */
-  isHighResolution() {
-    return this.width >= 3840 || this.height >= 2160;
-  }
-  /**
-   * AI-powered: Generate accessibility alt text for this image.
-   *
-   * Uses the `smrtImages.image.generateAltText` prompt registered via
-   * `@happyvertical/smrt-prompts`, allowing tenant- or instance-level
-   * overrides of the template, model, and parameters at runtime.
-   *
-   * Only non-PII metadata fields (name, description) are sent to the AI
-   * provider. Source URIs, internal foreign-key fields, and the
-   * extensible `metadata` blob are intentionally excluded — source URIs
-   * may embed signed/private bucket paths and metadata may contain EXIF
-   * GPS data or tenant-private configuration.
-   *
-   * @returns AI-generated alt text describing the image
-   */
-  async generateAltText() {
-    const db = this.options.db ?? this.options.persistence;
-    const resolvedPrompt = await resolvePrompt(
-      smrtImagesGenerateAltTextPrompt.key,
-      {
-        db,
-        tenantId: this.tenantId,
-        variables: {
-          imageName: this.name || "",
-          imageDescription: this.description || ""
-        }
-      }
-    );
-    const ai = await this.getAiClient();
-    const response = await ai.message(
-      resolvedPrompt.text,
-      promptMessageOptions(resolvedPrompt.ai)
-    );
-    const altText = response.trim();
-    this.alt = altText;
-    return altText;
-  }
+var Image = class extends Asset {
+	width = 0;
+	height = 0;
+	alt = "";
+	constructor(options = {}) {
+		super(options);
+		if (options.width !== void 0) this.width = options.width;
+		if (options.height !== void 0) this.height = options.height;
+		if (options.alt !== void 0) this.alt = options.alt;
+	}
+	/**
+	* Calculate aspect ratio from dimensions
+	*/
+	get aspectRatio() {
+		if (this.height === 0) return 0;
+		return this.width / this.height;
+	}
+	/**
+	* Helper to get URL from sourceUri for frontend components
+	*/
+	get url() {
+		return this.sourceUri;
+	}
+	/**
+	* Check if dimensions indicate landscape orientation
+	*/
+	get isLandscape() {
+		return this.width > this.height;
+	}
+	/**
+	* Check if dimensions indicate portrait orientation
+	*/
+	get isPortrait() {
+		return this.height > this.width;
+	}
+	/**
+	* Check if dimensions indicate square aspect ratio
+	*/
+	get isSquare() {
+		return this.width === this.height && this.width > 0;
+	}
+	/**
+	* Validate that the asset is an image based on MIME type
+	*/
+	isValidImageFormat() {
+		return this.mimeType.startsWith("image/");
+	}
+	/**
+	* Check if this image is high resolution (4K+)
+	*/
+	isHighResolution() {
+		return this.width >= 3840 || this.height >= 2160;
+	}
+	/**
+	* AI-powered: Generate accessibility alt text for this image.
+	*
+	* Uses the `smrtImages.image.generateAltText` prompt registered via
+	* `@happyvertical/smrt-prompts`, allowing tenant- or instance-level
+	* overrides of the template, model, and parameters at runtime.
+	*
+	* Only non-PII metadata fields (name, description) are sent to the AI
+	* provider. Source URIs, internal foreign-key fields, and the
+	* extensible `metadata` blob are intentionally excluded — source URIs
+	* may embed signed/private bucket paths and metadata may contain EXIF
+	* GPS data or tenant-private configuration.
+	*
+	* @returns AI-generated alt text describing the image
+	*/
+	async generateAltText() {
+		const db = this.options.db ?? this.options.persistence;
+		const resolvedPrompt = await resolvePrompt(smrtImagesGenerateAltTextPrompt.key, {
+			db,
+			tenantId: this.tenantId,
+			variables: {
+				imageName: this.name || "",
+				imageDescription: this.description || ""
+			}
+		});
+		const altText = (await (await this.getAiClient()).message(resolvedPrompt.text, promptMessageOptions(resolvedPrompt.ai))).trim();
+		this.alt = altText;
+		return altText;
+	}
 };
-__decorateClass([
-  field()
-], Image.prototype, "width", 2);
-__decorateClass([
-  field()
-], Image.prototype, "height", 2);
-__decorateClass([
-  field()
-], Image.prototype, "alt", 2);
-Image = __decorateClass([
-  TenantScoped({ mode: "optional" }),
-  smrt({
-    api: { include: ["list", "get", "create", "update", "delete"] },
-    mcp: { include: ["list", "get", "create", "update", "generateAltText"] },
-    cli: true
-  })
-], Image);
-const IMAGE_META_TYPE = "@happyvertical/smrt-images:Image";
-class ImageCollection extends SmrtCollection {
-  static _itemClass = Image;
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Tenant-Aware Query Methods
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Find all images belonging to a specific tenant
-   *
-   * @param tenantId - The tenant ID to filter by
-   * @returns Array of images belonging to this tenant
-   */
-  async findByTenant(tenantId) {
-    return await this.list({ where: { tenantId } });
-  }
-  /**
-   * Find all global images (images without a tenant)
-   *
-   * @returns Array of global images
-   */
-  async findGlobal() {
-    return await this.query(
-      `SELECT * FROM ${this.tableName}
+__decorateClass([field()], Image.prototype, "width", 2);
+__decorateClass([field()], Image.prototype, "height", 2);
+__decorateClass([field()], Image.prototype, "alt", 2);
+Image = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update",
+		"delete"
+	] },
+	mcp: { include: [
+		"list",
+		"get",
+		"create",
+		"update",
+		"generateAltText"
+	] },
+	cli: true
+})], Image);
+//#endregion
+//#region src/images.ts
+var IMAGE_META_TYPE = "@happyvertical/smrt-images:Image";
+var ImageCollection = class extends SmrtCollection {
+	static _itemClass = Image;
+	/**
+	* Find all images belonging to a specific tenant
+	*
+	* @param tenantId - The tenant ID to filter by
+	* @returns Array of images belonging to this tenant
+	*/
+	async findByTenant(tenantId) {
+		return await this.list({ where: { tenantId } });
+	}
+	/**
+	* Find all global images (images without a tenant)
+	*
+	* @returns Array of global images
+	*/
+	async findGlobal() {
+		return await this.query(`SELECT * FROM ${this.tableName}
        WHERE _meta_type = ?
-         AND tenant_id IS NULL`,
-      [IMAGE_META_TYPE],
-      { allowRawOnTenantScoped: true }
-    );
-  }
-  /**
-   * Find images belonging to a tenant plus all global images
-   *
-   * @param tenantId - The tenant ID to include
-   * @returns Array of tenant-specific and global images
-   */
-  async findWithGlobals(tenantId) {
-    const tenantContext = getCurrentTenant();
-    if (tenantContext && !isSuperAdminBypass() && tenantContext.tenantId !== tenantId) {
-      throw new TenantIsolationError(
-        `Tenant isolation violation in Image.findWithGlobals: context tenant is '${tenantContext.tenantId}' but query requested '${tenantId}'`,
-        { tenantId: tenantContext.tenantId, attemptedTenantId: tenantId }
-      );
-    }
-    return await this.query(
-      `SELECT * FROM ${this.tableName}
+         AND tenant_id IS NULL`, [IMAGE_META_TYPE], { allowRawOnTenantScoped: true });
+	}
+	/**
+	* Find images belonging to a tenant plus all global images
+	*
+	* @param tenantId - The tenant ID to include
+	* @returns Array of tenant-specific and global images
+	*/
+	async findWithGlobals(tenantId) {
+		const tenantContext = getCurrentTenant();
+		if (tenantContext && !isSuperAdminBypass() && tenantContext.tenantId !== tenantId) throw new TenantIsolationError(`Tenant isolation violation in Image.findWithGlobals: context tenant is '${tenantContext.tenantId}' but query requested '${tenantId}'`, {
+			tenantId: tenantContext.tenantId,
+			attemptedTenantId: tenantId
+		});
+		return await this.query(`SELECT * FROM ${this.tableName}
        WHERE _meta_type = ?
-         AND (tenant_id = ? OR tenant_id IS NULL)`,
-      [IMAGE_META_TYPE, tenantId],
-      { allowRawOnTenantScoped: true }
-    );
-  }
-  /**
-   * Get images by minimum dimensions
-   *
-   * @param minWidth - Minimum width in pixels
-   * @param minHeight - Minimum height in pixels
-   * @returns Array of images meeting minimum dimension requirements
-   */
-  async getByMinDimensions(minWidth, minHeight) {
-    return await this.list({
-      where: {
-        "width >=": minWidth,
-        "height >=": minHeight
-      }
-    });
-  }
-  /**
-   * Get images by maximum dimensions
-   *
-   * @param maxWidth - Maximum width in pixels
-   * @param maxHeight - Maximum height in pixels
-   * @returns Array of images within maximum dimension limits
-   */
-  async getByMaxDimensions(maxWidth, maxHeight) {
-    return await this.list({
-      where: {
-        "width <=": maxWidth,
-        "height <=": maxHeight
-      }
-    });
-  }
-  /**
-   * Get landscape images (width > height)
-   *
-   * @returns Array of landscape-oriented images
-   */
-  async getLandscape() {
-    const all = await this.list({});
-    return all.filter((image) => image.isLandscape);
-  }
-  /**
-   * Get portrait images (height > width)
-   *
-   * @returns Array of portrait-oriented images
-   */
-  async getPortrait() {
-    const all = await this.list({});
-    return all.filter((image) => image.isPortrait);
-  }
-  /**
-   * Get square images (width === height)
-   *
-   * @returns Array of square images
-   */
-  async getSquare() {
-    const all = await this.list({});
-    return all.filter((image) => image.isSquare);
-  }
-  /**
-   * Get images missing alt text
-   *
-   * @returns Array of images without accessibility text
-   */
-  async getMissingAltText() {
-    return await this.list({
-      where: { alt: "" }
-    });
-  }
-  /**
-   * Get high resolution images (4K+)
-   *
-   * @returns Array of high resolution images
-   */
-  async getHighResolution() {
-    const all = await this.list({});
-    return all.filter((image) => image.isHighResolution());
-  }
-  /**
-   * Get images by aspect ratio range
-   *
-   * @param minRatio - Minimum aspect ratio (width/height)
-   * @param maxRatio - Maximum aspect ratio (width/height)
-   * @returns Array of images within the aspect ratio range
-   */
-  async getByAspectRatio(minRatio, maxRatio) {
-    const all = await this.list({});
-    return all.filter(
-      (image) => image.height > 0 && image.aspectRatio >= minRatio && image.aspectRatio <= maxRatio
-    );
-  }
-}
-class ImageMetadataExtractor {
-  /**
-   * Extract metadata from an image buffer
-   *
-   * @param buffer - Raw image data
-   * @returns Extracted metadata including dimensions and format
-   */
-  async extract(buffer) {
-    const { getDimensions, getImageMetadata } = await import("@happyvertical/images");
-    const dimensions = await getDimensions(buffer);
-    const metadata = await getImageMetadata(buffer);
-    return {
-      width: dimensions.width,
-      height: dimensions.height,
-      format: metadata.format ?? "",
-      mimeType: metadata.format ? `image/${metadata.format}` : "image/unknown",
-      exif: metadata.exif
-    };
-  }
-  /**
-   * Extract metadata and apply it to an Image instance
-   *
-   * @param image - The Image instance to update
-   * @param buffer - Raw image data
-   */
-  async extractAndApply(image, buffer) {
-    const result = await this.extract(buffer);
-    image.width = result.width;
-    image.height = result.height;
-    if (result.mimeType) image.mimeType = result.mimeType;
-  }
-}
-class ImageSearch {
-  constructor(collection, _options = {}) {
-    this.collection = collection;
-    this._options = _options;
-  }
-  collection;
-  _options;
-  /**
-   * Search images by text query with optional dimension/orientation filters
-   *
-   * @param query - Text search query
-   * @param searchOptions - Optional filters for dimensions, orientation, etc.
-   * @returns Matching images
-   */
-  async search(query, searchOptions = {}) {
-    const where = {};
-    if (searchOptions.minWidth) where["width >="] = searchOptions.minWidth;
-    if (searchOptions.minHeight) where["height >="] = searchOptions.minHeight;
-    const fetchLimit = query ? (searchOptions.limit ?? 100) * 3 : searchOptions.limit;
-    let results = await this.collection.list({
-      where,
-      limit: fetchLimit,
-      offset: searchOptions.offset
-    });
-    if (query) {
-      const lowerQuery = query.toLowerCase();
-      results = results.filter(
-        (img) => img.name.toLowerCase().includes(lowerQuery) || img.description?.toLowerCase().includes(lowerQuery) || img.alt?.toLowerCase().includes(lowerQuery)
-      );
-    }
-    if (searchOptions.orientation) {
-      results = results.filter((img) => {
-        switch (searchOptions.orientation) {
-          case "landscape":
-            return img.isLandscape;
-          case "portrait":
-            return img.isPortrait;
-          case "square":
-            return img.isSquare;
-          default:
-            return true;
-        }
-      });
-    }
-    if (searchOptions.limit && results.length > searchOptions.limit) {
-      results = results.slice(0, searchOptions.limit);
-    }
-    return results;
-  }
-  /**
-   * Find images similar to a given image
-   *
-   * @param image - The reference image
-   * @param options - Search options
-   * @returns Similar images
-   */
-  async findSimilar(image, options = {}) {
-    const limit = options.limit ?? 10;
-    const ratio = image.aspectRatio;
-    const minRatio = ratio * 0.8;
-    const maxRatio = ratio * 1.2;
-    const candidates = await this.collection.getByAspectRatio(
-      minRatio,
-      maxRatio
-    );
-    return candidates.filter((c) => c.id !== image.id).slice(0, limit);
-  }
-  /**
-   * Find images matching a natural language prompt
-   *
-   * @param prompt - Natural language description of desired images
-   * @param options - Search options
-   * @returns Matching images
-   */
-  async findByPrompt(prompt, options = {}) {
-    return this.search(prompt, { limit: options.limit });
-  }
-}
-class UpstreamManager {
-  constructor(sources, store, collection) {
-    this.sources = sources;
-    this.store = store;
-    this.collection = collection;
-  }
-  sources;
-  store;
-  collection;
-  /**
-   * Search across all configured upstream sources
-   *
-   * @param query - Search query
-   * @param options - Search options
-   * @returns Merged and ranked results from all sources
-   */
-  async search(query, options = {}) {
-    const limit = options.limit ?? 20;
-    const allResults = [];
-    const searches = this.sources.filter((s) => s.capabilities.search).map(
-      (source) => source.search(query, { limit }).catch(() => [])
-    );
-    const results = await Promise.all(searches);
-    for (const sourceResults of results) {
-      allResults.push(...sourceResults);
-    }
-    return allResults.slice(0, limit);
-  }
-  /**
-   * Import an asset from an upstream source into the local store
-   *
-   * @param sourceAsset - The upstream asset to import
-   * @returns Locally stored Image with provenance
-   */
-  async import(sourceAsset) {
-    const adapter = this.sources.find((s) => s.name === sourceAsset.sourceName);
-    if (!adapter) {
-      throw new Error(`No adapter found for source: ${sourceAsset.sourceName}`);
-    }
-    const { data, metadata } = await adapter.download(sourceAsset.externalId);
-    const image = await this.collection.create({
-      name: sourceAsset.name,
-      sourceUri: "",
-      mimeType: sourceAsset.mimeType,
-      width: metadata.width ?? 0,
-      height: metadata.height ?? 0,
-      alt: metadata.description ?? "",
-      description: metadata.attribution ? `${metadata.description ?? ""} (${metadata.attribution})` : metadata.description ?? "",
-      sourceType: sourceAsset.sourceName,
-      externalId: sourceAsset.externalId,
-      typeSlug: "image"
-    });
-    const sourceUri = await this.store.storeFile(image, data, {
-      mimeType: sourceAsset.mimeType,
-      typeSlug: "image"
-    });
-    image.sourceUri = sourceUri;
-    await image.save();
-    return image;
-  }
-}
-export {
-  Image,
-  ImageCategorizer,
-  ImageCollection,
-  ImageDeriver,
-  ImageEditor,
-  ImageMetadataExtractor,
-  ImageSearch,
-  UpstreamManager,
-  persistMediaBundleInspection as persistImageMediaBundleInspection,
-  smrtImagesGenerateAltTextPrompt
+         AND (tenant_id = ? OR tenant_id IS NULL)`, [IMAGE_META_TYPE, tenantId], { allowRawOnTenantScoped: true });
+	}
+	/**
+	* Get images by minimum dimensions
+	*
+	* @param minWidth - Minimum width in pixels
+	* @param minHeight - Minimum height in pixels
+	* @returns Array of images meeting minimum dimension requirements
+	*/
+	async getByMinDimensions(minWidth, minHeight) {
+		return await this.list({ where: {
+			"width >=": minWidth,
+			"height >=": minHeight
+		} });
+	}
+	/**
+	* Get images by maximum dimensions
+	*
+	* @param maxWidth - Maximum width in pixels
+	* @param maxHeight - Maximum height in pixels
+	* @returns Array of images within maximum dimension limits
+	*/
+	async getByMaxDimensions(maxWidth, maxHeight) {
+		return await this.list({ where: {
+			"width <=": maxWidth,
+			"height <=": maxHeight
+		} });
+	}
+	/**
+	* Get landscape images (width > height)
+	*
+	* @returns Array of landscape-oriented images
+	*/
+	async getLandscape() {
+		return (await this.list({})).filter((image) => image.isLandscape);
+	}
+	/**
+	* Get portrait images (height > width)
+	*
+	* @returns Array of portrait-oriented images
+	*/
+	async getPortrait() {
+		return (await this.list({})).filter((image) => image.isPortrait);
+	}
+	/**
+	* Get square images (width === height)
+	*
+	* @returns Array of square images
+	*/
+	async getSquare() {
+		return (await this.list({})).filter((image) => image.isSquare);
+	}
+	/**
+	* Get images missing alt text
+	*
+	* @returns Array of images without accessibility text
+	*/
+	async getMissingAltText() {
+		return await this.list({ where: { alt: "" } });
+	}
+	/**
+	* Get high resolution images (4K+)
+	*
+	* @returns Array of high resolution images
+	*/
+	async getHighResolution() {
+		return (await this.list({})).filter((image) => image.isHighResolution());
+	}
+	/**
+	* Get images by aspect ratio range
+	*
+	* @param minRatio - Minimum aspect ratio (width/height)
+	* @param maxRatio - Maximum aspect ratio (width/height)
+	* @returns Array of images within the aspect ratio range
+	*/
+	async getByAspectRatio(minRatio, maxRatio) {
+		return (await this.list({})).filter((image) => image.height > 0 && image.aspectRatio >= minRatio && image.aspectRatio <= maxRatio);
+	}
+};
+//#endregion
+//#region src/metadata.ts
+var ImageMetadataExtractor = class {
+	/**
+	* Extract metadata from an image buffer
+	*
+	* @param buffer - Raw image data
+	* @returns Extracted metadata including dimensions and format
+	*/
+	async extract(buffer) {
+		const { getDimensions, getImageMetadata } = await import("@happyvertical/images");
+		const dimensions = await getDimensions(buffer);
+		const metadata = await getImageMetadata(buffer);
+		return {
+			width: dimensions.width,
+			height: dimensions.height,
+			format: metadata.format ?? "",
+			mimeType: metadata.format ? `image/${metadata.format}` : "image/unknown",
+			exif: metadata.exif
+		};
+	}
+	/**
+	* Extract metadata and apply it to an Image instance
+	*
+	* @param image - The Image instance to update
+	* @param buffer - Raw image data
+	*/
+	async extractAndApply(image, buffer) {
+		const result = await this.extract(buffer);
+		image.width = result.width;
+		image.height = result.height;
+		if (result.mimeType) image.mimeType = result.mimeType;
+	}
 };
-//# sourceMappingURL=index.js.map
+//#endregion
+//#region src/search.ts
+var ImageSearch = class {
+	constructor(collection, _options = {}) {
+		this.collection = collection;
+		this._options = _options;
+	}
+	collection;
+	_options;
+	/**
+	* Search images by text query with optional dimension/orientation filters
+	*
+	* @param query - Text search query
+	* @param searchOptions - Optional filters for dimensions, orientation, etc.
+	* @returns Matching images
+	*/
+	async search(query, searchOptions = {}) {
+		const where = {};
+		if (searchOptions.minWidth) where["width >="] = searchOptions.minWidth;
+		if (searchOptions.minHeight) where["height >="] = searchOptions.minHeight;
+		const fetchLimit = query ? (searchOptions.limit ?? 100) * 3 : searchOptions.limit;
+		let results = await this.collection.list({
+			where,
+			limit: fetchLimit,
+			offset: searchOptions.offset
+		});
+		if (query) {
+			const lowerQuery = query.toLowerCase();
+			results = results.filter((img) => img.name.toLowerCase().includes(lowerQuery) || img.description?.toLowerCase().includes(lowerQuery) || img.alt?.toLowerCase().includes(lowerQuery));
+		}
+		if (searchOptions.orientation) results = results.filter((img) => {
+			switch (searchOptions.orientation) {
+				case "landscape": return img.isLandscape;
+				case "portrait": return img.isPortrait;
+				case "square": return img.isSquare;
+				default: return true;
+			}
+		});
+		if (searchOptions.limit && results.length > searchOptions.limit) results = results.slice(0, searchOptions.limit);
+		return results;
+	}
+	/**
+	* Find images similar to a given image
+	*
+	* @param image - The reference image
+	* @param options - Search options
+	* @returns Similar images
+	*/
+	async findSimilar(image, options = {}) {
+		const limit = options.limit ?? 10;
+		const ratio = image.aspectRatio;
+		const minRatio = ratio * .8;
+		const maxRatio = ratio * 1.2;
+		return (await this.collection.getByAspectRatio(minRatio, maxRatio)).filter((c) => c.id !== image.id).slice(0, limit);
+	}
+	/**
+	* Find images matching a natural language prompt
+	*
+	* @param prompt - Natural language description of desired images
+	* @param options - Search options
+	* @returns Matching images
+	*/
+	async findByPrompt(prompt, options = {}) {
+		return this.search(prompt, { limit: options.limit });
+	}
+};
+//#endregion
+//#region src/upstream.ts
+var UpstreamManager = class {
+	constructor(sources, store, collection) {
+		this.sources = sources;
+		this.store = store;
+		this.collection = collection;
+	}
+	sources;
+	store;
+	collection;
+	/**
+	* Search across all configured upstream sources
+	*
+	* @param query - Search query
+	* @param options - Search options
+	* @returns Merged and ranked results from all sources
+	*/
+	async search(query, options = {}) {
+		const limit = options.limit ?? 20;
+		const allResults = [];
+		const searches = this.sources.filter((s) => s.capabilities.search).map((source) => source.search(query, { limit }).catch(() => []));
+		const results = await Promise.all(searches);
+		for (const sourceResults of results) allResults.push(...sourceResults);
+		return allResults.slice(0, limit);
+	}
+	/**
+	* Import an asset from an upstream source into the local store
+	*
+	* @param sourceAsset - The upstream asset to import
+	* @returns Locally stored Image with provenance
+	*/
+	async import(sourceAsset) {
+		const adapter = this.sources.find((s) => s.name === sourceAsset.sourceName);
+		if (!adapter) throw new Error(`No adapter found for source: ${sourceAsset.sourceName}`);
+		const { data, metadata } = await adapter.download(sourceAsset.externalId);
+		const image = await this.collection.create({
+			name: sourceAsset.name,
+			sourceUri: "",
+			mimeType: sourceAsset.mimeType,
+			width: metadata.width ?? 0,
+			height: metadata.height ?? 0,
+			alt: metadata.description ?? "",
+			description: metadata.attribution ? `${metadata.description ?? ""} (${metadata.attribution})` : metadata.description ?? "",
+			sourceType: sourceAsset.sourceName,
+			externalId: sourceAsset.externalId,
+			typeSlug: "image"
+		});
+		image.sourceUri = await this.store.storeFile(image, data, {
+			mimeType: sourceAsset.mimeType,
+			typeSlug: "image"
+		});
+		await image.save();
+		return image;
+	}
+};
+//#endregion
+export { Image, ImageCategorizer, ImageCollection, ImageDeriver, ImageEditor, ImageMetadataExtractor, ImageSearch, UpstreamManager, persistImageMediaBundleInspection, smrtImagesGenerateAltTextPrompt };
+
+//# sourceMappingURL=index.js.map