@camstack/addon-scene-intelligence 0.1.1

package/dist/index.d.mts

@@ -0,0 +1,87 @@
+import { ICamstackAddon, ISceneIntelligence, AddonManifest, AddonContext, CapabilityProviderMap, CropInput, ClassifierOutput, EmbeddingMetadata, EmbeddingFilter, VectorSearchResult, SceneStateResult, IScopedLogger, IEmbeddingsBackend, ModelCatalogEntry } from '@camstack/types';
+
+declare class SceneIntelligenceAddon implements ICamstackAddon, ISceneIntelligence {
+    readonly manifest: AddonManifest;
+    private logger;
+    private imageEncoder;
+    private textEncoder;
+    private sceneStateMachine;
+    private referenceStore;
+    private searchService;
+    private ctx;
+    initialize(context: AddonContext): Promise<void>;
+    shutdown(): Promise<void>;
+    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
+    classify(input: CropInput): Promise<ClassifierOutput>;
+    embed(deviceId: string, crop: Buffer, metadata: EmbeddingMetadata): Promise<string>;
+    search(query: string, topK: number, filter?: EmbeddingFilter): Promise<VectorSearchResult[]>;
+    searchByImage(image: Buffer, topK: number, filter?: EmbeddingFilter): Promise<VectorSearchResult[]>;
+    evaluateSceneState(deviceId: string, crop: Buffer): Promise<SceneStateResult | null>;
+    private ensureTextEncoder;
+}
+
+declare class ClipImageEncoder {
+    private session;
+    private readonly modelId;
+    private readonly inputSize;
+    private readonly logger;
+    constructor(modelId: string, logger: IScopedLogger);
+    load(modelPath: string): Promise<void>;
+    /**
+     * Encode a raw RGB buffer into a CLIP embedding.
+     * Caller must provide RGB buffer (use sharp to decode JPEG first).
+     */
+    encode(rgb: Buffer, width: number, height: number): Promise<Float32Array>;
+    dispose(): Promise<void>;
+}
+
+declare class ClipTextEncoder {
+    private session;
+    private readonly logger;
+    constructor(logger: IScopedLogger);
+    load(modelPath: string): Promise<void>;
+    encode(text: string): Promise<Float32Array>;
+    dispose(): Promise<void>;
+}
+
+declare class SearchService {
+    private readonly backend;
+    private index;
+    constructor(backend: IEmbeddingsBackend);
+    initialize(): Promise<void>;
+    storeEmbedding(id: string, embedding: Float32Array, metadata: EmbeddingMetadata): Promise<void>;
+    searchByVector(query: Float32Array, topK: number, filter?: EmbeddingFilter): Promise<readonly VectorSearchResult[]>;
+    count(): Promise<number>;
+    shutdown(): Promise<void>;
+}
+
+interface SceneStateDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly referenceEmbedding: Float32Array;
+    readonly threshold: number;
+}
+declare class SceneStateMachine {
+    private readonly debounceFrames;
+    private readonly cameraStates;
+    constructor(debounceFrames?: number);
+    evaluate(deviceId: string, embedding: Float32Array, referenceStates: readonly SceneStateDefinition[]): SceneStateResult | null;
+}
+
+declare const CLIP_MODELS: readonly ModelCatalogEntry[];
+declare const DEFAULT_CLIP_MODEL = "mobileclip-s0";
+declare const CLIP_EMBEDDING_DIM = 512;
+
+/**
+ * Preprocess raw RGB buffer for CLIP inference.
+ * Resizes (nearest-neighbor for speed), normalizes with CLIP mean/std, outputs NCHW Float32Array.
+ * For production use, the caller should use sharp to resize the JPEG to targetW×targetH
+ * before calling this with the raw RGB. This function handles normalization + layout.
+ */
+declare function preprocessForClip(rgb: Buffer, srcWidth: number, srcHeight: number, targetWidth: number, targetHeight: number): Float32Array;
+/**
+ * L2-normalize a vector in-place and return it.
+ */
+declare function l2Normalize(vec: Float32Array): Float32Array;
+
+export { CLIP_EMBEDDING_DIM, CLIP_MODELS, ClipImageEncoder, ClipTextEncoder, DEFAULT_CLIP_MODEL, SceneIntelligenceAddon, SceneStateMachine, SearchService, SceneIntelligenceAddon as default, l2Normalize, preprocessForClip };

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+import { ICamstackAddon, ISceneIntelligence, AddonManifest, AddonContext, CapabilityProviderMap, CropInput, ClassifierOutput, EmbeddingMetadata, EmbeddingFilter, VectorSearchResult, SceneStateResult, IScopedLogger, IEmbeddingsBackend, ModelCatalogEntry } from '@camstack/types';
+
+declare class SceneIntelligenceAddon implements ICamstackAddon, ISceneIntelligence {
+    readonly manifest: AddonManifest;
+    private logger;
+    private imageEncoder;
+    private textEncoder;
+    private sceneStateMachine;
+    private referenceStore;
+    private searchService;
+    private ctx;
+    initialize(context: AddonContext): Promise<void>;
+    shutdown(): Promise<void>;
+    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
+    classify(input: CropInput): Promise<ClassifierOutput>;
+    embed(deviceId: string, crop: Buffer, metadata: EmbeddingMetadata): Promise<string>;
+    search(query: string, topK: number, filter?: EmbeddingFilter): Promise<VectorSearchResult[]>;
+    searchByImage(image: Buffer, topK: number, filter?: EmbeddingFilter): Promise<VectorSearchResult[]>;
+    evaluateSceneState(deviceId: string, crop: Buffer): Promise<SceneStateResult | null>;
+    private ensureTextEncoder;
+}
+
+declare class ClipImageEncoder {
+    private session;
+    private readonly modelId;
+    private readonly inputSize;
+    private readonly logger;
+    constructor(modelId: string, logger: IScopedLogger);
+    load(modelPath: string): Promise<void>;
+    /**
+     * Encode a raw RGB buffer into a CLIP embedding.
+     * Caller must provide RGB buffer (use sharp to decode JPEG first).
+     */
+    encode(rgb: Buffer, width: number, height: number): Promise<Float32Array>;
+    dispose(): Promise<void>;
+}
+
+declare class ClipTextEncoder {
+    private session;
+    private readonly logger;
+    constructor(logger: IScopedLogger);
+    load(modelPath: string): Promise<void>;
+    encode(text: string): Promise<Float32Array>;
+    dispose(): Promise<void>;
+}
+
+declare class SearchService {
+    private readonly backend;
+    private index;
+    constructor(backend: IEmbeddingsBackend);
+    initialize(): Promise<void>;
+    storeEmbedding(id: string, embedding: Float32Array, metadata: EmbeddingMetadata): Promise<void>;
+    searchByVector(query: Float32Array, topK: number, filter?: EmbeddingFilter): Promise<readonly VectorSearchResult[]>;
+    count(): Promise<number>;
+    shutdown(): Promise<void>;
+}
+
+interface SceneStateDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly referenceEmbedding: Float32Array;
+    readonly threshold: number;
+}
+declare class SceneStateMachine {
+    private readonly debounceFrames;
+    private readonly cameraStates;
+    constructor(debounceFrames?: number);
+    evaluate(deviceId: string, embedding: Float32Array, referenceStates: readonly SceneStateDefinition[]): SceneStateResult | null;
+}
+
+declare const CLIP_MODELS: readonly ModelCatalogEntry[];
+declare const DEFAULT_CLIP_MODEL = "mobileclip-s0";
+declare const CLIP_EMBEDDING_DIM = 512;
+
+/**
+ * Preprocess raw RGB buffer for CLIP inference.
+ * Resizes (nearest-neighbor for speed), normalizes with CLIP mean/std, outputs NCHW Float32Array.
+ * For production use, the caller should use sharp to resize the JPEG to targetW×targetH
+ * before calling this with the raw RGB. This function handles normalization + layout.
+ */
+declare function preprocessForClip(rgb: Buffer, srcWidth: number, srcHeight: number, targetWidth: number, targetHeight: number): Float32Array;
+/**
+ * L2-normalize a vector in-place and return it.
+ */
+declare function l2Normalize(vec: Float32Array): Float32Array;
+
+export { CLIP_EMBEDDING_DIM, CLIP_MODELS, ClipImageEncoder, ClipTextEncoder, DEFAULT_CLIP_MODEL, SceneIntelligenceAddon, SceneStateMachine, SearchService, SceneIntelligenceAddon as default, l2Normalize, preprocessForClip };

package/dist/index.js

@@ -0,0 +1,525 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CLIP_EMBEDDING_DIM: () => CLIP_EMBEDDING_DIM,
+  CLIP_MODELS: () => CLIP_MODELS,
+  ClipImageEncoder: () => ClipImageEncoder,
+  ClipTextEncoder: () => ClipTextEncoder,
+  DEFAULT_CLIP_MODEL: () => DEFAULT_CLIP_MODEL,
+  SceneIntelligenceAddon: () => SceneIntelligenceAddon,
+  SceneStateMachine: () => SceneStateMachine,
+  SearchService: () => SearchService,
+  default: () => SceneIntelligenceAddon,
+  l2Normalize: () => l2Normalize,
+  preprocessForClip: () => preprocessForClip
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/clip/preprocessing.ts
+var CLIP_MEAN = [0.48145466, 0.4578275, 0.40821073];
+var CLIP_STD = [0.26862954, 0.26130258, 0.27577711];
+function preprocessForClip(rgb, srcWidth, srcHeight, targetWidth, targetHeight) {
+  const pixels = targetWidth * targetHeight;
+  const result = new Float32Array(3 * pixels);
+  for (let y = 0; y < targetHeight; y++) {
+    for (let x = 0; x < targetWidth; x++) {
+      const srcX = Math.min(Math.floor(x / targetWidth * srcWidth), srcWidth - 1);
+      const srcY = Math.min(Math.floor(y / targetHeight * srcHeight), srcHeight - 1);
+      const srcIdx = (srcY * srcWidth + srcX) * 3;
+      const dstIdx = y * targetWidth + x;
+      for (let c = 0; c < 3; c++) {
+        const val = (rgb[srcIdx + c] ?? 0) / 255;
+        const mean = CLIP_MEAN[c];
+        const std = CLIP_STD[c];
+        result[c * pixels + dstIdx] = (val - mean) / std;
+      }
+    }
+  }
+  return result;
+}
+function l2Normalize(vec) {
+  let norm = 0;
+  for (let i = 0; i < vec.length; i++) norm += vec[i] * vec[i];
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < vec.length; i++) vec[i] /= norm;
+  }
+  return vec;
+}
+
+// src/clip/models.ts
+var CLIP_MODELS = [
+  {
+    id: "mobileclip-s0",
+    name: "MobileCLIP-S0",
+    description: "Lightweight CLIP model optimized for edge devices (~60MB)",
+    inputSize: { width: 256, height: 256 },
+    labels: [],
+    inputLayout: "nchw",
+    inputNormalization: "none",
+    // We handle CLIP normalization ourselves
+    formats: {
+      onnx: {
+        url: "https://huggingface.co/nicovdw/mobileclip-s0-onnx/resolve/main/image_encoder.onnx",
+        sizeMB: 60
+      }
+    }
+  },
+  {
+    id: "mobileclip-s0-text",
+    name: "MobileCLIP-S0 Text Encoder",
+    description: "Text encoder for MobileCLIP-S0",
+    inputSize: { width: 0, height: 0 },
+    labels: [],
+    formats: {
+      onnx: {
+        url: "https://huggingface.co/nicovdw/mobileclip-s0-onnx/resolve/main/text_encoder.onnx",
+        sizeMB: 65
+      }
+    }
+  },
+  {
+    id: "clip-vit-b32",
+    name: "CLIP ViT-B/32",
+    description: "Standard OpenAI CLIP model, higher accuracy (~340MB)",
+    inputSize: { width: 224, height: 224 },
+    labels: [],
+    inputLayout: "nchw",
+    inputNormalization: "none",
+    formats: {
+      onnx: {
+        url: "https://huggingface.co/nicovdw/clip-vit-b32-onnx/resolve/main/image_encoder.onnx",
+        sizeMB: 340
+      }
+    }
+  },
+  {
+    id: "clip-vit-b32-text",
+    name: "CLIP ViT-B/32 Text Encoder",
+    description: "Text encoder for CLIP ViT-B/32",
+    inputSize: { width: 0, height: 0 },
+    labels: [],
+    formats: {
+      onnx: {
+        url: "https://huggingface.co/nicovdw/clip-vit-b32-onnx/resolve/main/text_encoder.onnx",
+        sizeMB: 170
+      }
+    }
+  }
+];
+var DEFAULT_CLIP_MODEL = "mobileclip-s0";
+var CLIP_EMBEDDING_DIM = 512;
+var MOBILECLIP_INPUT_SIZE = 256;
+var VITB32_INPUT_SIZE = 224;
+function getInputSize(modelId) {
+  if (modelId.startsWith("mobileclip")) return MOBILECLIP_INPUT_SIZE;
+  return VITB32_INPUT_SIZE;
+}
+function getTextModelId(imageModelId) {
+  return `${imageModelId}-text`;
+}
+
+// src/clip/image-encoder.ts
+var ClipImageEncoder = class {
+  session = null;
+  // onnxruntime InferenceSession
+  modelId;
+  inputSize;
+  logger;
+  constructor(modelId, logger) {
+    this.modelId = modelId;
+    this.inputSize = getInputSize(modelId);
+    this.logger = logger;
+  }
+  async load(modelPath) {
+    const ort = await import("onnxruntime-node");
+    this.session = await ort.InferenceSession.create(modelPath, {
+      executionProviders: ["cpu"]
+    });
+    this.logger.info(`CLIP image encoder loaded: ${this.modelId} (${this.inputSize}\xD7${this.inputSize})`);
+  }
+  /**
+   * Encode a raw RGB buffer into a CLIP embedding.
+   * Caller must provide RGB buffer (use sharp to decode JPEG first).
+   */
+  async encode(rgb, width, height) {
+    if (!this.session) throw new Error("Image encoder not loaded");
+    const ort = await import("onnxruntime-node");
+    const input = preprocessForClip(rgb, width, height, this.inputSize, this.inputSize);
+    const tensor = new ort.Tensor("float32", input, [1, 3, this.inputSize, this.inputSize]);
+    const feeds = {};
+    const inputName = this.session.inputNames[0];
+    feeds[inputName] = tensor;
+    const results = await this.session.run(feeds);
+    const outputName = this.session.outputNames[0];
+    const output = results[outputName].data;
+    const embedding = new Float32Array(output.slice(0, CLIP_EMBEDDING_DIM));
+    return l2Normalize(embedding);
+  }
+  async dispose() {
+    if (this.session) {
+      await this.session.release?.();
+      this.session = null;
+    }
+  }
+};
+
+// src/clip/tokenizer.ts
+var SOT_TOKEN = 49406;
+var EOT_TOKEN = 49407;
+var MAX_LENGTH = 77;
+function tokenize(text) {
+  const tokens = [SOT_TOKEN];
+  const cleaned = text.toLowerCase().trim();
+  for (const char of cleaned) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code < 256) {
+      tokens.push(code + 1);
+    }
+  }
+  tokens.push(EOT_TOKEN);
+  while (tokens.length < MAX_LENGTH) tokens.push(0);
+  if (tokens.length > MAX_LENGTH) tokens.length = MAX_LENGTH;
+  return BigInt64Array.from(tokens.map((t) => BigInt(t)));
+}
+
+// src/clip/text-encoder.ts
+var ClipTextEncoder = class {
+  session = null;
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  async load(modelPath) {
+    const ort = await import("onnxruntime-node");
+    this.session = await ort.InferenceSession.create(modelPath, {
+      executionProviders: ["cpu"]
+    });
+    this.logger.info("CLIP text encoder loaded");
+  }
+  async encode(text) {
+    if (!this.session) throw new Error("Text encoder not loaded");
+    const ort = await import("onnxruntime-node");
+    const tokens = tokenize(text);
+    const tensor = new ort.Tensor("int64", tokens, [1, 77]);
+    const feeds = {};
+    const inputName = this.session.inputNames[0];
+    feeds[inputName] = tensor;
+    const results = await this.session.run(feeds);
+    const outputName = this.session.outputNames[0];
+    const output = results[outputName].data;
+    const embedding = new Float32Array(output.slice(0, CLIP_EMBEDDING_DIM));
+    return l2Normalize(embedding);
+  }
+  async dispose() {
+    if (this.session) {
+      await this.session.release?.();
+      this.session = null;
+    }
+  }
+};
+
+// src/scene-state/state-machine.ts
+var import_types = require("@camstack/types");
+var SceneStateMachine = class {
+  debounceFrames;
+  cameraStates = /* @__PURE__ */ new Map();
+  constructor(debounceFrames = 3) {
+    this.debounceFrames = debounceFrames;
+  }
+  evaluate(deviceId, embedding, referenceStates) {
+    if (referenceStates.length === 0) return null;
+    let cs = this.cameraStates.get(deviceId);
+    if (!cs) {
+      cs = { currentState: null, pendingState: null, pendingCount: 0, pendingConfidence: 0 };
+      this.cameraStates.set(deviceId, cs);
+    }
+    let bestState = null;
+    let bestScore = -1;
+    for (const ref of referenceStates) {
+      const similarity = (0, import_types.cosineSimilarity)(embedding, ref.referenceEmbedding);
+      if (similarity >= ref.threshold && similarity > bestScore) {
+        bestScore = similarity;
+        bestState = ref.name;
+      }
+    }
+    if (!bestState) return null;
+    if (bestState === cs.pendingState) {
+      cs.pendingCount++;
+      cs.pendingConfidence = bestScore;
+    } else {
+      cs.pendingState = bestState;
+      cs.pendingCount = 1;
+      cs.pendingConfidence = bestScore;
+    }
+    if (cs.pendingCount < this.debounceFrames) return null;
+    if (bestState === cs.currentState) return null;
+    const previousState = cs.currentState ?? "unknown";
+    cs.currentState = bestState;
+    cs.pendingState = null;
+    cs.pendingCount = 0;
+    return {
+      previousState,
+      currentState: bestState,
+      confidence: bestScore
+    };
+  }
+};
+
+// src/scene-state/reference-store.ts
+var COLLECTION = "device-settings";
+var ReferenceStore = class {
+  settingsBackend;
+  constructor(settingsBackend) {
+    this.settingsBackend = settingsBackend;
+  }
+  async getStatesForCamera(deviceId) {
+    const raw = await this.settingsBackend.get(COLLECTION, `scene-states:${deviceId}`);
+    if (!raw || !Array.isArray(raw)) return [];
+    return raw.map((s) => ({
+      id: s.id,
+      name: s.name,
+      referenceEmbedding: new Float32Array(s.referenceEmbedding),
+      threshold: s.threshold ?? 0.7
+    }));
+  }
+  async setStatesForCamera(deviceId, states) {
+    const serializable = states.map((s) => ({
+      id: s.id,
+      name: s.name,
+      referenceEmbedding: Array.from(s.referenceEmbedding),
+      threshold: s.threshold
+    }));
+    await this.settingsBackend.set(COLLECTION, `scene-states:${deviceId}`, serializable);
+  }
+};
+
+// src/search/search-service.ts
+var INDEX_NAME = "clip-embeddings";
+var SearchService = class {
+  backend;
+  index = null;
+  constructor(backend) {
+    this.backend = backend;
+  }
+  async initialize() {
+    this.index = await this.backend.openIndex(INDEX_NAME, CLIP_EMBEDDING_DIM);
+  }
+  async storeEmbedding(id, embedding, metadata) {
+    if (!this.index) return;
+    await this.index.insert(id, embedding, metadata);
+  }
+  async searchByVector(query, topK, filter) {
+    if (!this.index) return [];
+    return this.index.search(query, topK, filter);
+  }
+  async count() {
+    return this.index?.count() ?? 0;
+  }
+  async shutdown() {
+    await this.index?.flush();
+    this.index = null;
+  }
+};
+
+// src/addon.ts
+var SceneIntelligenceAddon = class {
+  manifest = {
+    id: "scene-intelligence",
+    name: "Scene Intelligence",
+    version: "0.1.0",
+    description: "CLIP embeddings, semantic search, and scene state detection",
+    slot: "classifier",
+    inputClasses: [],
+    outputClasses: [],
+    labelOutputType: "classification",
+    passive: false,
+    capabilities: [
+      { name: "scene-intelligence", mode: "singleton" }
+    ],
+    defaultConfig: {
+      modelId: DEFAULT_CLIP_MODEL,
+      minConfidence: 0.5
+    }
+  };
+  logger;
+  imageEncoder = null;
+  textEncoder = null;
+  sceneStateMachine = null;
+  referenceStore = null;
+  searchService = null;
+  ctx = null;
+  async initialize(context) {
+    this.ctx = context;
+    this.logger = context.logger;
+    const modelId = context.addonConfig["modelId"] ?? DEFAULT_CLIP_MODEL;
+    if (context.models) {
+      try {
+        const imagePath = await context.models.ensure(modelId, "onnx");
+        this.imageEncoder = new ClipImageEncoder(modelId, this.logger);
+        await this.imageEncoder.load(imagePath);
+      } catch (err) {
+        this.logger.warn(`Failed to load CLIP image encoder: ${err}`);
+      }
+    }
+    this.sceneStateMachine = new SceneStateMachine(3);
+    if (context.settingsBackend) {
+      this.referenceStore = new ReferenceStore(context.settingsBackend);
+    }
+    if (context.embeddingsBackend) {
+      this.searchService = new SearchService(context.embeddingsBackend);
+      await this.searchService.initialize();
+    }
+    this.logger.info(`Scene Intelligence initialized (model=${modelId})`);
+  }
+  async shutdown() {
+    await this.imageEncoder?.dispose();
+    await this.textEncoder?.dispose();
+    await this.searchService?.shutdown();
+    this.imageEncoder = null;
+    this.textEncoder = null;
+    this.searchService = null;
+    this.sceneStateMachine = null;
+    this.referenceStore = null;
+    this.ctx = null;
+  }
+  getCapabilityProvider(name) {
+    if (name === "scene-intelligence") {
+      return this;
+    }
+    return null;
+  }
+  // --- IClassifierProvider (pipeline classifier slot) ---
+  async classify(input) {
+    if (!this.imageEncoder) {
+      return { classifications: [], inferenceMs: 0, modelId: "none" };
+    }
+    const start = performance.now();
+    try {
+      const sharp = await import("sharp").then((m) => m.default ?? m);
+      const { data, info } = await sharp(input.frame.data).extract({
+        left: Math.round(input.roi.x),
+        top: Math.round(input.roi.y),
+        width: Math.round(input.roi.w),
+        height: Math.round(input.roi.h)
+      }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+      const embedding = await this.imageEncoder.encode(data, info.width, info.height);
+      const inferenceMs = performance.now() - start;
+      if (this.searchService) {
+        const embeddingId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.searchService.storeEmbedding(embeddingId, embedding, {
+          timestamp: Date.now(),
+          className: input.parentDetection.class,
+          deviceId: ""
+        }).catch(() => {
+        });
+      }
+      return {
+        classifications: [{
+          class: "clip-embedding",
+          score: 1,
+          embedding,
+          metadata: { embeddingDim: embedding.length }
+        }],
+        inferenceMs,
+        modelId: this.manifest.defaultConfig?.["modelId"] ?? DEFAULT_CLIP_MODEL
+      };
+    } catch (err) {
+      this.logger.debug(`CLIP classify failed: ${err}`);
+      return { classifications: [], inferenceMs: performance.now() - start, modelId: "error" };
+    }
+  }
+  // --- ISceneIntelligence ---
+  async embed(deviceId, crop, metadata) {
+    if (!this.imageEncoder || !this.searchService) throw new Error("Not initialized");
+    const sharp = await import("sharp").then((m) => m.default ?? m);
+    const { data, info } = await sharp(crop).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+    const embedding = await this.imageEncoder.encode(data, info.width, info.height);
+    const id = `${deviceId}/${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await this.searchService.storeEmbedding(id, embedding, metadata);
+    return id;
+  }
+  async search(query, topK, filter) {
+    if (!this.searchService) return [];
+    const textEncoder = await this.ensureTextEncoder();
+    if (!textEncoder) return [];
+    const queryEmbedding = await textEncoder.encode(query);
+    const results = await this.searchService.searchByVector(queryEmbedding, topK, filter);
+    return [...results];
+  }
+  async searchByImage(image, topK, filter) {
+    if (!this.imageEncoder || !this.searchService) return [];
+    const sharp = await import("sharp").then((m) => m.default ?? m);
+    const { data, info } = await sharp(image).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+    const embedding = await this.imageEncoder.encode(data, info.width, info.height);
+    const results = await this.searchService.searchByVector(embedding, topK, filter);
+    return [...results];
+  }
+  async evaluateSceneState(deviceId, crop) {
+    if (!this.imageEncoder || !this.sceneStateMachine || !this.referenceStore) return null;
+    const sharp = await import("sharp").then((m) => m.default ?? m);
+    const { data, info } = await sharp(crop).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+    const embedding = await this.imageEncoder.encode(data, info.width, info.height);
+    const states = await this.referenceStore.getStatesForCamera(deviceId);
+    return this.sceneStateMachine.evaluate(deviceId, embedding, states);
+  }
+  // --- Private ---
+  async ensureTextEncoder() {
+    if (this.textEncoder) return this.textEncoder;
+    if (!this.ctx?.models) return null;
+    const modelId = this.ctx.addonConfig["modelId"] ?? DEFAULT_CLIP_MODEL;
+    const textModelId = getTextModelId(modelId);
+    try {
+      const textPath = await this.ctx.models.ensure(textModelId, "onnx");
+      this.textEncoder = new ClipTextEncoder(this.logger);
+      await this.textEncoder.load(textPath);
+      return this.textEncoder;
+    } catch (err) {
+      this.logger.warn(`Failed to load CLIP text encoder: ${err}`);
+      return null;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLIP_EMBEDDING_DIM,
+  CLIP_MODELS,
+  ClipImageEncoder,
+  ClipTextEncoder,
+  DEFAULT_CLIP_MODEL,
+  SceneIntelligenceAddon,
+  SceneStateMachine,
+  SearchService,
+  l2Normalize,
+  preprocessForClip
+});
+//# sourceMappingURL=index.js.map