@openrfid/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,742 @@
+// src/lifecycle.ts
+var ComponentState = /* @__PURE__ */ ((ComponentState2) => {
+  ComponentState2["UNINITIALIZED"] = "UNINITIALIZED";
+  ComponentState2["INITIALIZED"] = "INITIALIZED";
+  ComponentState2["RUNNING"] = "RUNNING";
+  ComponentState2["STOPPED"] = "STOPPED";
+  ComponentState2["DISPOSED"] = "DISPOSED";
+  ComponentState2["ERROR"] = "ERROR";
+  return ComponentState2;
+})(ComponentState || {});
+
+// src/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    const eventName = String(event);
+    if (!this.listeners.has(eventName)) {
+      this.listeners.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventName).add(handler);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    const eventName = String(event);
+    const handlers = this.listeners.get(eventName);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.listeners.delete(eventName);
+      }
+    }
+  }
+  async emit(event, payload) {
+    const eventName = String(event);
+    const handlers = this.listeners.get(eventName);
+    if (handlers) {
+      const promises = [];
+      for (const handler of handlers) {
+        try {
+          promises.push(handler(payload));
+        } catch (err) {
+          console.error(`Error in event handler for event '${eventName}':`, err);
+        }
+      }
+      await Promise.all(promises);
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(String(event));
+    } else {
+      this.listeners.clear();
+    }
+  }
+  listenerCount(event) {
+    return this.listeners.get(String(event))?.size ?? 0;
+  }
+};
+
+// src/di-container.ts
+var Container = class {
+  services = /* @__PURE__ */ new Map();
+  register(key, factory, singleton = true) {
+    this.services.set(key, { factory, singleton });
+  }
+  registerInstance(key, instance) {
+    this.services.set(key, { factory: () => instance, singleton: true, instance });
+  }
+  resolve(key) {
+    const service = this.services.get(key);
+    if (!service) {
+      throw new Error(`Service '${key}' is not registered in the DI Container.`);
+    }
+    if (service.singleton) {
+      if (!service.instance) {
+        service.instance = service.factory(this);
+      }
+      return service.instance;
+    }
+    return service.factory(this);
+  }
+  has(key) {
+    return this.services.has(key);
+  }
+  reset() {
+    this.services.clear();
+  }
+};
+
+// src/config-manager.ts
+var defaultConfig = {
+  server: {
+    port: 3e3,
+    host: "0.0.0.0"
+  },
+  mqtt: {
+    enabled: false,
+    brokerUrl: "mqtt://localhost:1883",
+    topicPrefix: "openrfid"
+  },
+  websocket: {
+    port: 3001
+  },
+  storage: {
+    dbPath: "./openrfid.db",
+    memoryEventLimit: 1e4,
+    eventWarningThreshold: 8e3,
+    autoTrimEnabled: true
+  },
+  simulator: {
+    defaultReadIntervalMs: 500,
+    defaultRssi: -55
+  }
+};
+var ConfigManager = class {
+  config;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(initialConfig = {}) {
+    this.config = this.deepMerge({ ...defaultConfig }, initialConfig);
+  }
+  get(path) {
+    const keys = path.split(".");
+    let current = this.config;
+    for (const key of keys) {
+      if (current === void 0 || current === null) return void 0;
+      current = current[key];
+    }
+    return current;
+  }
+  set(path, value) {
+    const keys = path.split(".");
+    let current = this.config;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!current[key] || typeof current[key] !== "object") {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+    this.notify();
+  }
+  getAll() {
+    return { ...this.config };
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify() {
+    const freezeCopy = Object.freeze({ ...this.config });
+    for (const listener of this.listeners) {
+      listener(freezeCopy);
+    }
+  }
+  deepMerge(target, source) {
+    const output = { ...target };
+    for (const key of Object.keys(source)) {
+      if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+        output[key] = this.deepMerge(target[key] ?? {}, source[key]);
+      } else {
+        output[key] = source[key];
+      }
+    }
+    return output;
+  }
+};
+
+// src/logger.ts
+var Logger = class {
+  constructor(context = "App", minLevel = "info") {
+    this.context = context;
+    this.minLevel = minLevel;
+  }
+  context;
+  minLevel;
+  levelWeights = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  log(level, message, data) {
+    if (this.levelWeights[level] < this.levelWeights[this.minLevel]) {
+      return;
+    }
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      context: this.context,
+      message,
+      data
+    };
+    const formatted = `[${entry.timestamp}] [${level.toUpperCase()}] [${entry.context}]: ${message}`;
+    if (level === "error") {
+      console.error(formatted, data !== void 0 ? data : "");
+    } else if (level === "warn") {
+      console.warn(formatted, data !== void 0 ? data : "");
+    } else {
+      console.log(formatted, data !== void 0 ? data : "");
+    }
+  }
+};
+
+// src/storage-memory.ts
+var MemoryStorageDriver = class {
+  constructor(config) {
+    this.config = config;
+    this.maxEvents = config?.get("storage.memoryEventLimit") ?? 1e4;
+    this.warningThreshold = config?.get("storage.eventWarningThreshold") ?? 8e3;
+    this.autoTrim = config?.get("storage.autoTrimEnabled") ?? true;
+    if (config) {
+      this.configUnsubscribe = config.onChange((cfg) => {
+        this.maxEvents = cfg.storage?.memoryEventLimit ?? 1e4;
+        this.warningThreshold = cfg.storage?.eventWarningThreshold ?? 8e3;
+        this.autoTrim = cfg.storage?.autoTrimEnabled ?? true;
+        if (this.events.length > this.maxEvents) {
+          this.events.length = this.maxEvents;
+        }
+      });
+    }
+  }
+  config;
+  readers = /* @__PURE__ */ new Map();
+  tags = /* @__PURE__ */ new Map();
+  antennas = /* @__PURE__ */ new Map();
+  events = [];
+  connected = false;
+  maxEvents;
+  warningThreshold;
+  autoTrim;
+  configUnsubscribe;
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.configUnsubscribe?.();
+  }
+  // Reader CRUD
+  async getReaders() {
+    return Array.from(this.readers.values());
+  }
+  async getReaderById(id) {
+    return this.readers.get(id) ?? null;
+  }
+  async saveReader(reader) {
+    this.readers.set(reader.id, reader);
+  }
+  async deleteReader(id) {
+    this.readers.delete(id);
+    for (const key of Array.from(this.antennas.keys())) {
+      if (this.antennas.get(key)?.readerId === id) {
+        this.antennas.delete(key);
+      }
+    }
+  }
+  // Antenna Persistence
+  async saveAntenna(antenna) {
+    this.antennas.set(antenna.id, antenna);
+  }
+  async getAntennasByReaderId(readerId) {
+    return Array.from(this.antennas.values()).filter((a) => a.readerId === readerId);
+  }
+  // Tag CRUD
+  async getTags() {
+    return Array.from(this.tags.values());
+  }
+  async getTagByEpc(epc) {
+    for (const tag of this.tags.values()) {
+      if (tag.epc === epc) return tag;
+    }
+    return null;
+  }
+  async saveTag(tag) {
+    this.tags.set(tag.id, tag);
+  }
+  async deleteTag(id) {
+    this.tags.delete(id);
+  }
+  // Event Log — basic
+  async logEvent(event) {
+    this.events.unshift(event);
+    if (this.autoTrim && this.events.length > this.maxEvents) {
+      this.events.length = this.maxEvents;
+    }
+  }
+  // Event Log — advanced queries
+  async getEvents(options = {}) {
+    let results = [...this.events];
+    if (options.date) results = results.filter((e) => e.date === options.date);
+    if (options.from) results = results.filter((e) => e.timestamp >= options.from);
+    if (options.to) results = results.filter((e) => e.timestamp <= options.to);
+    if (options.readerId) results = results.filter((e) => e.readerId === options.readerId);
+    if (options.epc) results = results.filter((e) => e.epc === options.epc);
+    if (options.protocol) results = results.filter((e) => e.protocol === options.protocol);
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? 1e3;
+    return results.slice(offset, offset + limit);
+  }
+  async getEventsByDate(date, limit = 1e3, offset = 0) {
+    const filtered = this.events.filter((e) => e.date === date);
+    return filtered.slice(offset, offset + limit);
+  }
+  async getEventDates() {
+    const map = /* @__PURE__ */ new Map();
+    for (const e of this.events) {
+      map.set(e.date, (map.get(e.date) ?? 0) + 1);
+    }
+    return Array.from(map.entries()).map(([date, count]) => ({ date, count })).sort((a, b) => b.date.localeCompare(a.date));
+  }
+  async getEventStats() {
+    const byDate = await this.getEventDates();
+    const dates = byDate.map((d) => d.date).sort();
+    return {
+      totalEvents: this.events.length,
+      totalDays: byDate.length,
+      oldestEventDate: dates[0] ?? null,
+      newestEventDate: dates[dates.length - 1] ?? null,
+      eventsByDate: byDate
+    };
+  }
+  async getEventCount(options = {}) {
+    const results = await this.getEvents({ ...options, limit: Number.MAX_SAFE_INTEGER, offset: 0 });
+    return results.length;
+  }
+  // Event Log — management
+  async deleteEventsByDate(date) {
+    const before = this.events.length;
+    this.events = this.events.filter((e) => e.date !== date);
+    return { deleted: before - this.events.length };
+  }
+  async clearAllEvents() {
+    const deleted = this.events.length;
+    this.events = [];
+    return { deleted };
+  }
+  // Nuclear clear
+  async clearAllData() {
+    this.readers.clear();
+    this.tags.clear();
+    this.antennas.clear();
+    this.events = [];
+  }
+  // Memory stats for dashboard UI
+  getMemoryUsage() {
+    const percent = Math.round(this.events.length / this.maxEvents * 100);
+    return {
+      current: this.events.length,
+      limit: this.maxEvents,
+      percent,
+      isWarning: this.events.length >= this.warningThreshold
+    };
+  }
+  setMemoryLimit(limit) {
+    const clamped = Math.max(100, Math.min(5e5, limit));
+    this.maxEvents = clamped;
+    if (this.events.length > clamped) {
+      this.events.length = clamped;
+    }
+    this.config?.set("storage.memoryEventLimit", clamped);
+  }
+};
+
+// src/storage-sqlite.ts
+import Database from "better-sqlite3";
+var SqliteStorageDriver = class {
+  constructor(dbPath = ":memory:") {
+    this.dbPath = dbPath;
+  }
+  dbPath;
+  db = null;
+  async connect() {
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.initTables();
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  initTables() {
+    if (!this.db) return;
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS readers (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        vendor TEXT NOT NULL,
+        model TEXT NOT NULL,
+        ip TEXT NOT NULL,
+        port INTEGER NOT NULL,
+        protocol TEXT NOT NULL,
+        status TEXT NOT NULL,
+        createdAt TEXT NOT NULL,
+        readRate INTEGER DEFAULT 0,
+        readMode TEXT DEFAULT 'continuous',
+        readIntervalValue INTEGER DEFAULT 1,
+        readIntervalUnit TEXT DEFAULT 'seconds',
+        epcFilterStart TEXT DEFAULT '',
+        epcFilterEnd TEXT DEFAULT '',
+        epcFilterPrefix TEXT DEFAULT ''
+      );
+
+      CREATE TABLE IF NOT EXISTS antennas (
+        id TEXT PRIMARY KEY,
+        reader_id TEXT NOT NULL,
+        antenna_index INTEGER NOT NULL,
+        gain REAL NOT NULL,
+        power REAL NOT NULL,
+        frequency REAL NOT NULL,
+        rssi_offset REAL NOT NULL,
+        read_zone TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        FOREIGN KEY (reader_id) REFERENCES readers(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS tags (
+        id TEXT PRIMARY KEY,
+        epc TEXT UNIQUE NOT NULL,
+        tid TEXT,
+        userMemory TEXT,
+        accessPassword TEXT,
+        killPassword TEXT,
+        protocol TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        date TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        readerId TEXT NOT NULL,
+        antennaId INTEGER NOT NULL,
+        epc TEXT NOT NULL,
+        rssi REAL NOT NULL,
+        protocol TEXT NOT NULL,
+        payload TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS plugins (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        version TEXT NOT NULL,
+        status TEXT NOT NULL,
+        config TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_events_date ON events(date);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_epc ON events(epc);
+      CREATE INDEX IF NOT EXISTS idx_events_reader ON events(readerId);
+      CREATE INDEX IF NOT EXISTS idx_tags_epc ON tags(epc);
+    `);
+  }
+  // ─── Readers ─────────────────────────────────────────────────────────────
+  async getReaders() {
+    this.checkConnection();
+    return this.db.prepare("SELECT * FROM readers").all();
+  }
+  async getReaderById(id) {
+    this.checkConnection();
+    const row = this.db.prepare("SELECT * FROM readers WHERE id = ?").get(id);
+    return row ? row : null;
+  }
+  async saveReader(reader) {
+    this.checkConnection();
+    this.db.prepare(`
+      INSERT INTO readers (id, name, vendor, model, ip, port, protocol, status, createdAt,
+                           readRate, readMode, readIntervalValue, readIntervalUnit,
+                           epcFilterStart, epcFilterEnd, epcFilterPrefix)
+      VALUES (@id, @name, @vendor, @model, @ip, @port, @protocol, @status, @createdAt,
+              @readRate, @readMode, @readIntervalValue, @readIntervalUnit,
+              @epcFilterStart, @epcFilterEnd, @epcFilterPrefix)
+      ON CONFLICT(id) DO UPDATE SET
+        name=excluded.name, vendor=excluded.vendor, model=excluded.model,
+        ip=excluded.ip, port=excluded.port, protocol=excluded.protocol,
+        status=excluded.status, readRate=excluded.readRate, readMode=excluded.readMode,
+        readIntervalValue=excluded.readIntervalValue, readIntervalUnit=excluded.readIntervalUnit,
+        epcFilterStart=excluded.epcFilterStart, epcFilterEnd=excluded.epcFilterEnd,
+        epcFilterPrefix=excluded.epcFilterPrefix
+    `).run({
+      ...reader,
+      readRate: reader.readRate ?? 0,
+      readMode: reader.readMode ?? "continuous",
+      readIntervalValue: reader.readIntervalValue ?? 1,
+      readIntervalUnit: reader.readIntervalUnit ?? "seconds",
+      epcFilterStart: reader.epcFilterStart ?? "",
+      epcFilterEnd: reader.epcFilterEnd ?? "",
+      epcFilterPrefix: reader.epcFilterPrefix ?? ""
+    });
+  }
+  async deleteReader(id) {
+    this.checkConnection();
+    this.db.prepare("DELETE FROM readers WHERE id = ?").run(id);
+  }
+  // ─── Antennas ─────────────────────────────────────────────────────────────
+  async saveAntenna(antenna) {
+    this.checkConnection();
+    this.db.prepare(`
+      INSERT INTO antennas (id, reader_id, antenna_index, gain, power, frequency, rssi_offset, read_zone, enabled)
+      VALUES (@id, @readerId, @index, @gain, @power, @frequency, @rssiOffset, @readZone, @enabled)
+      ON CONFLICT(id) DO UPDATE SET
+        gain=excluded.gain, power=excluded.power, frequency=excluded.frequency,
+        rssi_offset=excluded.rssi_offset, read_zone=excluded.read_zone, enabled=excluded.enabled
+    `).run({
+      id: antenna.id,
+      readerId: antenna.readerId,
+      index: antenna.index,
+      gain: antenna.gain,
+      power: antenna.power,
+      frequency: antenna.frequency,
+      rssiOffset: antenna.rssiOffset,
+      readZone: antenna.readZone,
+      enabled: antenna.enabled ? 1 : 0
+    });
+  }
+  async getAntennasByReaderId(readerId) {
+    this.checkConnection();
+    const rows = this.db.prepare("SELECT * FROM antennas WHERE reader_id = ?").all(readerId);
+    return rows.map((r) => ({
+      id: r.id,
+      readerId: r.reader_id,
+      index: r.antenna_index,
+      gain: r.gain,
+      power: r.power,
+      frequency: r.frequency,
+      rssiOffset: r.rssi_offset,
+      readZone: r.read_zone,
+      enabled: r.enabled === 1
+    }));
+  }
+  // ─── Tags ─────────────────────────────────────────────────────────────────
+  async getTags() {
+    this.checkConnection();
+    return this.db.prepare("SELECT * FROM tags").all();
+  }
+  async getTagByEpc(epc) {
+    this.checkConnection();
+    const row = this.db.prepare("SELECT * FROM tags WHERE epc = ?").get(epc);
+    return row ? row : null;
+  }
+  async saveTag(tag) {
+    this.checkConnection();
+    this.db.prepare(`
+      INSERT INTO tags (id, epc, tid, userMemory, accessPassword, killPassword, protocol)
+      VALUES (@id, @epc, @tid, @userMemory, @accessPassword, @killPassword, @protocol)
+      ON CONFLICT(epc) DO UPDATE SET
+        tid=excluded.tid, userMemory=excluded.userMemory,
+        accessPassword=excluded.accessPassword, killPassword=excluded.killPassword,
+        protocol=excluded.protocol
+    `).run({
+      id: tag.id,
+      epc: tag.epc,
+      tid: tag.tid ?? null,
+      userMemory: tag.userMemory ?? null,
+      accessPassword: tag.accessPassword ?? null,
+      killPassword: tag.killPassword ?? null,
+      protocol: tag.protocol ?? null
+    });
+  }
+  async deleteTag(id) {
+    this.checkConnection();
+    this.db.prepare("DELETE FROM tags WHERE id = ?").run(id);
+  }
+  // ─── Events — basic ───────────────────────────────────────────────────────
+  async logEvent(event) {
+    this.checkConnection();
+    this.db.prepare(`
+      INSERT INTO events (id, date, timestamp, readerId, antennaId, epc, rssi, protocol, payload)
+      VALUES (@id, @date, @timestamp, @readerId, @antennaId, @epc, @rssi, @protocol, @payload)
+    `).run({
+      id: event.id,
+      date: event.date,
+      timestamp: event.timestamp,
+      readerId: event.readerId,
+      antennaId: event.antennaId,
+      epc: event.epc,
+      rssi: event.rssi,
+      protocol: event.protocol,
+      payload: event.payload ?? null
+    });
+  }
+  // ─── Events — advanced queries ────────────────────────────────────────────
+  async getEvents(options = {}) {
+    this.checkConnection();
+    let sql = "SELECT * FROM events WHERE 1=1";
+    const params = [];
+    if (options.date) {
+      sql += " AND date = ?";
+      params.push(options.date);
+    }
+    if (options.from) {
+      sql += " AND timestamp >= ?";
+      params.push(options.from);
+    }
+    if (options.to) {
+      sql += " AND timestamp <= ?";
+      params.push(options.to);
+    }
+    if (options.readerId) {
+      sql += " AND readerId = ?";
+      params.push(options.readerId);
+    }
+    if (options.epc) {
+      sql += " AND epc = ?";
+      params.push(options.epc);
+    }
+    if (options.protocol) {
+      sql += " AND protocol = ?";
+      params.push(options.protocol);
+    }
+    sql += " ORDER BY timestamp DESC";
+    sql += ` LIMIT ${options.limit ?? 1e3} OFFSET ${options.offset ?? 0}`;
+    return this.db.prepare(sql).all(...params);
+  }
+  async getEventsByDate(date, limit = 1e3, offset = 0) {
+    this.checkConnection();
+    return this.db.prepare(
+      "SELECT * FROM events WHERE date = ? ORDER BY timestamp DESC LIMIT ? OFFSET ?"
+    ).all(date, limit, offset);
+  }
+  async getEventDates() {
+    this.checkConnection();
+    return this.db.prepare(
+      "SELECT date, COUNT(*) as count FROM events GROUP BY date ORDER BY date DESC"
+    ).all();
+  }
+  async getEventStats() {
+    this.checkConnection();
+    const total = this.db.prepare("SELECT COUNT(*) as n FROM events").get().n;
+    const oldest = this.db.prepare("SELECT MIN(date) as d FROM events").get().d;
+    const newest = this.db.prepare("SELECT MAX(date) as d FROM events").get().d;
+    const byDate = await this.getEventDates();
+    return {
+      totalEvents: total,
+      totalDays: byDate.length,
+      oldestEventDate: oldest,
+      newestEventDate: newest,
+      eventsByDate: byDate
+    };
+  }
+  async getEventCount(options = {}) {
+    this.checkConnection();
+    let sql = "SELECT COUNT(*) as n FROM events WHERE 1=1";
+    const params = [];
+    if (options.date) {
+      sql += " AND date = ?";
+      params.push(options.date);
+    }
+    if (options.from) {
+      sql += " AND timestamp >= ?";
+      params.push(options.from);
+    }
+    if (options.to) {
+      sql += " AND timestamp <= ?";
+      params.push(options.to);
+    }
+    if (options.readerId) {
+      sql += " AND readerId = ?";
+      params.push(options.readerId);
+    }
+    if (options.epc) {
+      sql += " AND epc = ?";
+      params.push(options.epc);
+    }
+    if (options.protocol) {
+      sql += " AND protocol = ?";
+      params.push(options.protocol);
+    }
+    return this.db.prepare(sql).get(...params).n;
+  }
+  // ─── Events — management ─────────────────────────────────────────────────
+  async deleteEventsByDate(date) {
+    this.checkConnection();
+    const result = this.db.prepare("DELETE FROM events WHERE date = ?").run(date);
+    return { deleted: result.changes };
+  }
+  async clearAllEvents() {
+    this.checkConnection();
+    const result = this.db.prepare("DELETE FROM events").run();
+    return { deleted: result.changes };
+  }
+  // Nuclear clear — wipes all data
+  async clearAllData() {
+    this.checkConnection();
+    this.db.exec("DELETE FROM events; DELETE FROM tags; DELETE FROM readers; DELETE FROM antennas;");
+  }
+  // ─── Internal ────────────────────────────────────────────────────────────
+  checkConnection() {
+    if (!this.db) {
+      throw new Error("Database is not connected. Call connect() first.");
+    }
+  }
+};
+
+// src/branding.ts
+var BRAND = {
+  name: "OpenRFID Simulator",
+  tagline: "The Open Source RFID Reader Simulator for Developers",
+  organization: "RFID Software India Private Limited",
+  website: "https://rfidsoftwares.com",
+  docsUrl: "https://rfidsoftwares.com/docs",
+  githubUrl: "https://github.com/rfidsoftwares/openrfid-simulator",
+  license: "MIT",
+  copyright: "Copyright (c) 2026 RFID Software India Private Limited - https://rfidsoftwares.com",
+  headerBanner: `/**
+ * OpenRFID Simulator - The Open Source RFID Reader Simulator for Developers.
+ * Copyright (c) 2026 RFID Software India Private Limited - https://rfidsoftwares.com
+ *
+ * Licensed under the MIT License.
+ * For RFID software, enterprise tools, and hardware drivers, visit https://rfidsoftwares.com
+ */`
+};
+export {
+  BRAND,
+  ComponentState,
+  ConfigManager,
+  Container,
+  EventBus,
+  Logger,
+  MemoryStorageDriver,
+  SqliteStorageDriver,
+  defaultConfig
+};