@openrfid/simulator 0.1.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 RFID Software India Private Limited - https://rfidsoftwares.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+For RFID developer resources, documentation, hardware integrations, and enterprise software solutions, visit https://rfidsoftwares.com

package/dist/index.d.mts

@@ -0,0 +1,77 @@
+import { EventBus, IStorageDriver } from '@openrfid/core';
+import { VirtualReader } from '@openrfid/readers';
+import { Tag } from '@openrfid/tags';
+
+/**
+ * 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
+ */
+
+interface InventoryOptions {
+    readIntervalMs?: number;
+    readProbability?: number;
+    baseRssi?: number;
+    maxTagsPerSecond?: number;
+    epcFilterStart?: string;
+    epcFilterEnd?: string;
+    epcFilterPrefix?: string;
+}
+declare class InventoryEngine {
+    private reader;
+    /** A1 fix — accepts a live getter instead of a frozen snapshot */
+    private getTags;
+    private eventBus;
+    private options;
+    private timer;
+    private isRunning;
+    private lastSecondStart;
+    private tagsReadThisSecond;
+    constructor(reader: VirtualReader, 
+    /** A1 fix — accepts a live getter instead of a frozen snapshot */
+    getTags: () => Tag[], eventBus: EventBus, options?: InventoryOptions);
+    private getPeriodicIntervalMs;
+    private getEffectiveOptions;
+    start(): void;
+    stop(): void;
+    executeReadCycle(): number;
+    getStatus(): boolean;
+}
+
+/**
+ * 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
+ */
+
+declare class SimulatorManager {
+    eventBus: EventBus;
+    storage?: IStorageDriver | undefined;
+    private readers;
+    private tags;
+    private engines;
+    constructor(eventBus: EventBus, storage?: IStorageDriver | undefined);
+    loadFromStorage(): Promise<void>;
+    getStorageSummary(): {
+        readerCount: number;
+        tagCount: number;
+    };
+    addReader(reader: VirtualReader): void;
+    removeReader(readerId: string): void;
+    getReader(readerId: string): VirtualReader | undefined;
+    getAllReaders(): VirtualReader[];
+    addTag(tag: Tag): void;
+    addTagBatch(tags: Tag[]): void;
+    removeTag(epc: string): void;
+    getAllTags(): Tag[];
+    startReader(readerId: string, options?: InventoryOptions): void;
+    stopReader(readerId: string): void;
+    startAll(options?: InventoryOptions): void;
+    stopAll(): void;
+}
+
+export { InventoryEngine, type InventoryOptions, SimulatorManager };

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { EventBus, IStorageDriver } from '@openrfid/core';
+import { VirtualReader } from '@openrfid/readers';
+import { Tag } from '@openrfid/tags';
+
+/**
+ * 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
+ */
+
+interface InventoryOptions {
+    readIntervalMs?: number;
+    readProbability?: number;
+    baseRssi?: number;
+    maxTagsPerSecond?: number;
+    epcFilterStart?: string;
+    epcFilterEnd?: string;
+    epcFilterPrefix?: string;
+}
+declare class InventoryEngine {
+    private reader;
+    /** A1 fix — accepts a live getter instead of a frozen snapshot */
+    private getTags;
+    private eventBus;
+    private options;
+    private timer;
+    private isRunning;
+    private lastSecondStart;
+    private tagsReadThisSecond;
+    constructor(reader: VirtualReader, 
+    /** A1 fix — accepts a live getter instead of a frozen snapshot */
+    getTags: () => Tag[], eventBus: EventBus, options?: InventoryOptions);
+    private getPeriodicIntervalMs;
+    private getEffectiveOptions;
+    start(): void;
+    stop(): void;
+    executeReadCycle(): number;
+    getStatus(): boolean;
+}
+
+/**
+ * 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
+ */
+
+declare class SimulatorManager {
+    eventBus: EventBus;
+    storage?: IStorageDriver | undefined;
+    private readers;
+    private tags;
+    private engines;
+    constructor(eventBus: EventBus, storage?: IStorageDriver | undefined);
+    loadFromStorage(): Promise<void>;
+    getStorageSummary(): {
+        readerCount: number;
+        tagCount: number;
+    };
+    addReader(reader: VirtualReader): void;
+    removeReader(readerId: string): void;
+    getReader(readerId: string): VirtualReader | undefined;
+    getAllReaders(): VirtualReader[];
+    addTag(tag: Tag): void;
+    addTagBatch(tags: Tag[]): void;
+    removeTag(epc: string): void;
+    getAllTags(): Tag[];
+    startReader(readerId: string, options?: InventoryOptions): void;
+    stopReader(readerId: string): void;
+    startAll(options?: InventoryOptions): void;
+    stopAll(): void;
+}
+
+export { InventoryEngine, type InventoryOptions, SimulatorManager };

package/dist/index.js

@@ -0,0 +1,305 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InventoryEngine: () => InventoryEngine,
+  SimulatorManager: () => SimulatorManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/inventory-engine.ts
+var import_utils = require("@openrfid/utils");
+var InventoryEngine = class {
+  constructor(reader, getTags, eventBus, options = {}) {
+    this.reader = reader;
+    this.getTags = getTags;
+    this.eventBus = eventBus;
+    this.options = options;
+  }
+  reader;
+  getTags;
+  eventBus;
+  options;
+  timer = null;
+  isRunning = false;
+  lastSecondStart = 0;
+  tagsReadThisSecond = 0;
+  getPeriodicIntervalMs() {
+    const value = this.reader.readIntervalValue || 1;
+    const unit = this.reader.readIntervalUnit || "seconds";
+    if (unit === "hours") return value * 60 * 60 * 1e3;
+    if (unit === "minutes") return value * 60 * 1e3;
+    return value * 1e3;
+  }
+  getEffectiveOptions() {
+    return {
+      readIntervalMs: this.reader.readMode === "periodic" ? this.getPeriodicIntervalMs() : this.options.readIntervalMs || 500,
+      readProbability: this.options.readProbability ?? 0.95,
+      baseRssi: this.options.baseRssi ?? -55,
+      maxTagsPerSecond: this.options.maxTagsPerSecond ?? this.reader.readRate,
+      epcFilterStart: this.options.epcFilterStart ?? this.reader.epcFilterStart,
+      epcFilterEnd: this.options.epcFilterEnd ?? this.reader.epcFilterEnd,
+      epcFilterPrefix: this.options.epcFilterPrefix ?? this.reader.epcFilterPrefix
+    };
+  }
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.reader.setStatus("ONLINE");
+    this.eventBus.emit("ReaderConnected", {
+      readerId: this.reader.id,
+      name: this.reader.name,
+      ip: this.reader.ip,
+      port: this.reader.port
+    }).catch((e) => console.error("[EventBus] ReaderConnected error:", e));
+    const effectiveOpts = this.getEffectiveOptions();
+    const interval = effectiveOpts.readIntervalMs;
+    this.timer = setInterval(() => {
+      this.executeReadCycle();
+    }, interval);
+  }
+  stop() {
+    if (!this.isRunning) return;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.isRunning = false;
+    this.reader.setStatus("OFFLINE");
+    this.eventBus.emit("ReaderDisconnected", {
+      readerId: this.reader.id,
+      reason: "Simulator stopped"
+    }).catch((e) => console.error("[EventBus] ReaderDisconnected error:", e));
+  }
+  executeReadCycle() {
+    if (this.reader.status !== "ONLINE") return 0;
+    let readCount = 0;
+    const activeAntennas = this.reader.getActiveAntennas();
+    if (activeAntennas.length === 0) return 0;
+    const effectiveOpts = this.getEffectiveOptions();
+    const baseProb = effectiveOpts.readProbability;
+    const baseRssi = effectiveOpts.baseRssi;
+    const now = Date.now();
+    if (now - this.lastSecondStart >= 1e3) {
+      this.lastSecondStart = now;
+      this.tagsReadThisSecond = 0;
+    }
+    let tagsToRead = this.getTags();
+    if (effectiveOpts.epcFilterPrefix) {
+      const prefix = effectiveOpts.epcFilterPrefix.toUpperCase();
+      tagsToRead = tagsToRead.filter((tag) => tag.epc.startsWith(prefix));
+    }
+    if (effectiveOpts.epcFilterStart || effectiveOpts.epcFilterEnd) {
+      tagsToRead = tagsToRead.filter((tag) => {
+        const epc = tag.epc;
+        if (effectiveOpts.epcFilterStart && epc < effectiveOpts.epcFilterStart.toUpperCase()) return false;
+        if (effectiveOpts.epcFilterEnd && epc > effectiveOpts.epcFilterEnd.toUpperCase()) return false;
+        return true;
+      });
+    }
+    for (const tag of tagsToRead) {
+      if (effectiveOpts.maxTagsPerSecond > 0 && this.tagsReadThisSecond >= effectiveOpts.maxTagsPerSecond) {
+        break;
+      }
+      for (const antenna of activeAntennas) {
+        if (effectiveOpts.maxTagsPerSecond > 0 && this.tagsReadThisSecond >= effectiveOpts.maxTagsPerSecond) {
+          break;
+        }
+        const antennaFactor = (antenna.power + antenna.gain) / 36;
+        const totalProb = Math.min(1, baseProb * antennaFactor);
+        if (import_utils.RandomGenerator.boolean(totalProb)) {
+          const rssiNoise = import_utils.RandomGenerator.gaussian(0, 2.5);
+          const calculatedRssi = parseFloat((baseRssi + antenna.rssiOffset + rssiNoise).toFixed(1));
+          tag.recordRead(calculatedRssi);
+          readCount++;
+          this.tagsReadThisSecond++;
+          this.eventBus.emit("TagDetected", {
+            readerId: this.reader.id,
+            antennaId: antenna.index,
+            epc: tag.epc,
+            tid: tag.tid,
+            rssi: calculatedRssi,
+            timestamp: Date.now(),
+            protocol: tag.protocol
+          }).catch((e) => console.error("[EventBus] TagDetected error:", e));
+        }
+      }
+    }
+    return readCount;
+  }
+  getStatus() {
+    return this.isRunning;
+  }
+};
+
+// src/simulator-manager.ts
+var import_readers = require("@openrfid/readers");
+var import_tags = require("@openrfid/tags");
+var SimulatorManager = class {
+  constructor(eventBus, storage) {
+    this.eventBus = eventBus;
+    this.storage = storage;
+    this.eventBus.on("TagDetected", (payload) => {
+      const now = /* @__PURE__ */ new Date();
+      const date = now.toISOString().split("T")[0];
+      this.storage?.logEvent({
+        id: `ev_${now.getTime()}_${Math.random().toString(36).slice(2, 7)}`,
+        date,
+        timestamp: now.toISOString(),
+        readerId: payload.readerId,
+        antennaId: payload.antennaId,
+        epc: payload.epc,
+        rssi: payload.rssi,
+        protocol: payload.protocol ?? "GEN2"
+      });
+    });
+  }
+  eventBus;
+  storage;
+  readers = /* @__PURE__ */ new Map();
+  tags = /* @__PURE__ */ new Map();
+  engines = /* @__PURE__ */ new Map();
+  // A3.1 — Load readers and tags from storage on startup
+  async loadFromStorage() {
+    if (!this.storage) return;
+    const readers = await this.storage.getReaders();
+    for (const r of readers) {
+      const reader = new import_readers.VirtualReader(r);
+      const antennas = await this.storage.getAntennasByReaderId(reader.id);
+      if (antennas && antennas.length > 0) {
+        reader.antennas.clear();
+        for (const ant of antennas) {
+          reader.addAntenna(ant);
+        }
+      }
+      this.readers.set(reader.id, reader);
+    }
+    const tags = await this.storage.getTags();
+    for (const t of tags) {
+      const tag = new import_tags.Tag(t);
+      this.tags.set(tag.epc, tag);
+    }
+  }
+  // Returns summary for the startup banner
+  getStorageSummary() {
+    return {
+      readerCount: this.readers.size,
+      tagCount: this.tags.size
+    };
+  }
+  addReader(reader) {
+    this.readers.set(reader.id, reader);
+    if (this.storage) {
+      this.storage.saveReader(reader.toJSON());
+      for (const antenna of reader.antennas.values()) {
+        this.storage.saveAntenna({
+          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
+        });
+      }
+    }
+  }
+  removeReader(readerId) {
+    this.stopReader(readerId);
+    this.readers.delete(readerId);
+    if (this.storage) {
+      this.storage.deleteReader(readerId);
+    }
+  }
+  getReader(readerId) {
+    return this.readers.get(readerId);
+  }
+  getAllReaders() {
+    return Array.from(this.readers.values());
+  }
+  addTag(tag) {
+    this.tags.set(tag.epc, tag);
+    if (this.storage) {
+      this.storage.saveTag(tag.toJSON());
+    }
+  }
+  addTagBatch(tags) {
+    for (const tag of tags) {
+      this.addTag(tag);
+    }
+  }
+  removeTag(epc) {
+    const tag = this.tags.get(epc);
+    if (tag) {
+      this.tags.delete(epc);
+      if (this.storage) {
+        this.storage.deleteTag(tag.id);
+      }
+    }
+  }
+  getAllTags() {
+    return Array.from(this.tags.values());
+  }
+  startReader(readerId, options) {
+    const reader = this.readers.get(readerId);
+    if (!reader) {
+      throw new Error(`Reader '${readerId}' not found.`);
+    }
+    const engine = new InventoryEngine(
+      reader,
+      () => Array.from(this.tags.values()),
+      // A1 — live tag getter
+      this.eventBus,
+      options
+    );
+    this.engines.set(readerId, engine);
+    engine.start();
+  }
+  stopReader(readerId) {
+    const engine = this.engines.get(readerId);
+    if (engine) {
+      engine.stop();
+      this.engines.delete(readerId);
+    }
+  }
+  // B2 fix — wrap each start in try/catch so one failure doesn't stop others
+  startAll(options) {
+    for (const reader of this.readers.values()) {
+      try {
+        this.startReader(reader.id, options);
+      } catch (e) {
+        console.error(`[Simulator] Failed to start reader '${reader.id}': ${e.message}`);
+      }
+    }
+  }
+  stopAll() {
+    for (const readerId of Array.from(this.engines.keys())) {
+      this.stopReader(readerId);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InventoryEngine,
+  SimulatorManager
+});

package/dist/index.mjs

@@ -0,0 +1,277 @@
+// src/inventory-engine.ts
+import { RandomGenerator } from "@openrfid/utils";
+var InventoryEngine = class {
+  constructor(reader, getTags, eventBus, options = {}) {
+    this.reader = reader;
+    this.getTags = getTags;
+    this.eventBus = eventBus;
+    this.options = options;
+  }
+  reader;
+  getTags;
+  eventBus;
+  options;
+  timer = null;
+  isRunning = false;
+  lastSecondStart = 0;
+  tagsReadThisSecond = 0;
+  getPeriodicIntervalMs() {
+    const value = this.reader.readIntervalValue || 1;
+    const unit = this.reader.readIntervalUnit || "seconds";
+    if (unit === "hours") return value * 60 * 60 * 1e3;
+    if (unit === "minutes") return value * 60 * 1e3;
+    return value * 1e3;
+  }
+  getEffectiveOptions() {
+    return {
+      readIntervalMs: this.reader.readMode === "periodic" ? this.getPeriodicIntervalMs() : this.options.readIntervalMs || 500,
+      readProbability: this.options.readProbability ?? 0.95,
+      baseRssi: this.options.baseRssi ?? -55,
+      maxTagsPerSecond: this.options.maxTagsPerSecond ?? this.reader.readRate,
+      epcFilterStart: this.options.epcFilterStart ?? this.reader.epcFilterStart,
+      epcFilterEnd: this.options.epcFilterEnd ?? this.reader.epcFilterEnd,
+      epcFilterPrefix: this.options.epcFilterPrefix ?? this.reader.epcFilterPrefix
+    };
+  }
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.reader.setStatus("ONLINE");
+    this.eventBus.emit("ReaderConnected", {
+      readerId: this.reader.id,
+      name: this.reader.name,
+      ip: this.reader.ip,
+      port: this.reader.port
+    }).catch((e) => console.error("[EventBus] ReaderConnected error:", e));
+    const effectiveOpts = this.getEffectiveOptions();
+    const interval = effectiveOpts.readIntervalMs;
+    this.timer = setInterval(() => {
+      this.executeReadCycle();
+    }, interval);
+  }
+  stop() {
+    if (!this.isRunning) return;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.isRunning = false;
+    this.reader.setStatus("OFFLINE");
+    this.eventBus.emit("ReaderDisconnected", {
+      readerId: this.reader.id,
+      reason: "Simulator stopped"
+    }).catch((e) => console.error("[EventBus] ReaderDisconnected error:", e));
+  }
+  executeReadCycle() {
+    if (this.reader.status !== "ONLINE") return 0;
+    let readCount = 0;
+    const activeAntennas = this.reader.getActiveAntennas();
+    if (activeAntennas.length === 0) return 0;
+    const effectiveOpts = this.getEffectiveOptions();
+    const baseProb = effectiveOpts.readProbability;
+    const baseRssi = effectiveOpts.baseRssi;
+    const now = Date.now();
+    if (now - this.lastSecondStart >= 1e3) {
+      this.lastSecondStart = now;
+      this.tagsReadThisSecond = 0;
+    }
+    let tagsToRead = this.getTags();
+    if (effectiveOpts.epcFilterPrefix) {
+      const prefix = effectiveOpts.epcFilterPrefix.toUpperCase();
+      tagsToRead = tagsToRead.filter((tag) => tag.epc.startsWith(prefix));
+    }
+    if (effectiveOpts.epcFilterStart || effectiveOpts.epcFilterEnd) {
+      tagsToRead = tagsToRead.filter((tag) => {
+        const epc = tag.epc;
+        if (effectiveOpts.epcFilterStart && epc < effectiveOpts.epcFilterStart.toUpperCase()) return false;
+        if (effectiveOpts.epcFilterEnd && epc > effectiveOpts.epcFilterEnd.toUpperCase()) return false;
+        return true;
+      });
+    }
+    for (const tag of tagsToRead) {
+      if (effectiveOpts.maxTagsPerSecond > 0 && this.tagsReadThisSecond >= effectiveOpts.maxTagsPerSecond) {
+        break;
+      }
+      for (const antenna of activeAntennas) {
+        if (effectiveOpts.maxTagsPerSecond > 0 && this.tagsReadThisSecond >= effectiveOpts.maxTagsPerSecond) {
+          break;
+        }
+        const antennaFactor = (antenna.power + antenna.gain) / 36;
+        const totalProb = Math.min(1, baseProb * antennaFactor);
+        if (RandomGenerator.boolean(totalProb)) {
+          const rssiNoise = RandomGenerator.gaussian(0, 2.5);
+          const calculatedRssi = parseFloat((baseRssi + antenna.rssiOffset + rssiNoise).toFixed(1));
+          tag.recordRead(calculatedRssi);
+          readCount++;
+          this.tagsReadThisSecond++;
+          this.eventBus.emit("TagDetected", {
+            readerId: this.reader.id,
+            antennaId: antenna.index,
+            epc: tag.epc,
+            tid: tag.tid,
+            rssi: calculatedRssi,
+            timestamp: Date.now(),
+            protocol: tag.protocol
+          }).catch((e) => console.error("[EventBus] TagDetected error:", e));
+        }
+      }
+    }
+    return readCount;
+  }
+  getStatus() {
+    return this.isRunning;
+  }
+};
+
+// src/simulator-manager.ts
+import { VirtualReader } from "@openrfid/readers";
+import { Tag } from "@openrfid/tags";
+var SimulatorManager = class {
+  constructor(eventBus, storage) {
+    this.eventBus = eventBus;
+    this.storage = storage;
+    this.eventBus.on("TagDetected", (payload) => {
+      const now = /* @__PURE__ */ new Date();
+      const date = now.toISOString().split("T")[0];
+      this.storage?.logEvent({
+        id: `ev_${now.getTime()}_${Math.random().toString(36).slice(2, 7)}`,
+        date,
+        timestamp: now.toISOString(),
+        readerId: payload.readerId,
+        antennaId: payload.antennaId,
+        epc: payload.epc,
+        rssi: payload.rssi,
+        protocol: payload.protocol ?? "GEN2"
+      });
+    });
+  }
+  eventBus;
+  storage;
+  readers = /* @__PURE__ */ new Map();
+  tags = /* @__PURE__ */ new Map();
+  engines = /* @__PURE__ */ new Map();
+  // A3.1 — Load readers and tags from storage on startup
+  async loadFromStorage() {
+    if (!this.storage) return;
+    const readers = await this.storage.getReaders();
+    for (const r of readers) {
+      const reader = new VirtualReader(r);
+      const antennas = await this.storage.getAntennasByReaderId(reader.id);
+      if (antennas && antennas.length > 0) {
+        reader.antennas.clear();
+        for (const ant of antennas) {
+          reader.addAntenna(ant);
+        }
+      }
+      this.readers.set(reader.id, reader);
+    }
+    const tags = await this.storage.getTags();
+    for (const t of tags) {
+      const tag = new Tag(t);
+      this.tags.set(tag.epc, tag);
+    }
+  }
+  // Returns summary for the startup banner
+  getStorageSummary() {
+    return {
+      readerCount: this.readers.size,
+      tagCount: this.tags.size
+    };
+  }
+  addReader(reader) {
+    this.readers.set(reader.id, reader);
+    if (this.storage) {
+      this.storage.saveReader(reader.toJSON());
+      for (const antenna of reader.antennas.values()) {
+        this.storage.saveAntenna({
+          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
+        });
+      }
+    }
+  }
+  removeReader(readerId) {
+    this.stopReader(readerId);
+    this.readers.delete(readerId);
+    if (this.storage) {
+      this.storage.deleteReader(readerId);
+    }
+  }
+  getReader(readerId) {
+    return this.readers.get(readerId);
+  }
+  getAllReaders() {
+    return Array.from(this.readers.values());
+  }
+  addTag(tag) {
+    this.tags.set(tag.epc, tag);
+    if (this.storage) {
+      this.storage.saveTag(tag.toJSON());
+    }
+  }
+  addTagBatch(tags) {
+    for (const tag of tags) {
+      this.addTag(tag);
+    }
+  }
+  removeTag(epc) {
+    const tag = this.tags.get(epc);
+    if (tag) {
+      this.tags.delete(epc);
+      if (this.storage) {
+        this.storage.deleteTag(tag.id);
+      }
+    }
+  }
+  getAllTags() {
+    return Array.from(this.tags.values());
+  }
+  startReader(readerId, options) {
+    const reader = this.readers.get(readerId);
+    if (!reader) {
+      throw new Error(`Reader '${readerId}' not found.`);
+    }
+    const engine = new InventoryEngine(
+      reader,
+      () => Array.from(this.tags.values()),
+      // A1 — live tag getter
+      this.eventBus,
+      options
+    );
+    this.engines.set(readerId, engine);
+    engine.start();
+  }
+  stopReader(readerId) {
+    const engine = this.engines.get(readerId);
+    if (engine) {
+      engine.stop();
+      this.engines.delete(readerId);
+    }
+  }
+  // B2 fix — wrap each start in try/catch so one failure doesn't stop others
+  startAll(options) {
+    for (const reader of this.readers.values()) {
+      try {
+        this.startReader(reader.id, options);
+      } catch (e) {
+        console.error(`[Simulator] Failed to start reader '${reader.id}': ${e.message}`);
+      }
+    }
+  }
+  stopAll() {
+    for (const readerId of Array.from(this.engines.keys())) {
+      this.stopReader(readerId);
+    }
+  }
+};
+export {
+  InventoryEngine,
+  SimulatorManager
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@openrfid/simulator",
+  "version": "0.1.0",
+  "description": "Core RFID inventory engine, read cycle loops, read probability model, and event pipeline.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@openrfid/core": "0.1.0",
+    "@openrfid/tags": "0.1.0",
+    "@openrfid/utils": "0.1.0",
+    "@openrfid/readers": "0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rfidsoftwares/openrfid-simulator.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rfidsoftwares/openrfid-simulator/issues"
+  },
+  "homepage": "https://rfidsoftwares.com",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}