@happyvertical/smrt-images 0.30.0

package/dist/index.js

@@ -0,0 +1,839 @@
+import { ObjectRegistry, field, smrt, SmrtCollection } 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 { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Asset } from "@happyvertical/smrt-assets";
+import { persistMediaBundleInspection } from "@happyvertical/smrt-assets";
+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.
+Consider: subject matter, key visual elements, context.
+Keep it under 125 characters for screen reader compatibility.
+
+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
+  }
+});
+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 } : {}
+  };
+}
+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.
+Image name: ${image.name}
+Image description: ${image.description}
+MIME type: ${image.mimeType}
+Dimensions: ${image.width}x${image.height}
+
+Respond in JSON format:
+{
+  "tags": ["tag1", "tag2", ...],
+  "description": "Brief description of the image content",
+  "confidence": 0.0-1.0,
+  "subjects": ["subject1", "subject2", ...]
+}`;
+    const response = await ai.chat([{ role: "user", content: prompt }]);
+    const text = response.content;
+    try {
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+    } catch {
+    }
+    return {
+      tags: [],
+      description: image.description || image.name,
+      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"
+]);
+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 __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;
+};
+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;
+  }
+};
+__decorateClass([
+  field()
+], Image.prototype, "width", 2);
+__decorateClass([
+  field()
+], Image.prototype, "height", 2);
+__decorateClass([
+  field()
+], Image.prototype, "alt", 2);
+Image = __decorateClass([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create", "update", "generateAltText"] },
+    cli: true
+  })
+], 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.list({ where: { tenantId: null } });
+  }
+  /**
+   * 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) {
+    return await this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId]
+    );
+  }
+  /**
+   * 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.query(
+      `SELECT * FROM ${this.tableName} WHERE width > height`
+    );
+  }
+  /**
+   * Get portrait images (height > width)
+   *
+   * @returns Array of portrait-oriented images
+   */
+  async getPortrait() {
+    return await this.query(
+      `SELECT * FROM ${this.tableName} WHERE height > width`
+    );
+  }
+  /**
+   * Get square images (width === height)
+   *
+   * @returns Array of square images
+   */
+  async getSquare() {
+    return await this.query(
+      `SELECT * FROM ${this.tableName} WHERE width = height AND width > 0`
+    );
+  }
+  /**
+   * 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.query(
+      `SELECT * FROM ${this.tableName} WHERE width >= 3840 OR height >= 2160`
+    );
+  }
+  /**
+   * 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.query(
+      `SELECT * FROM ${this.tableName}
+       WHERE height > 0
+         AND (CAST(width AS REAL) / height) >= ?
+         AND (CAST(width AS REAL) / height) <= ?`,
+      [minRatio, 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
+};
+//# sourceMappingURL=index.js.map