@openrfid/rest 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,52 @@
+import { FastifyInstance } from 'fastify';
+import { IPlugin, PluginMetadata, PluginContext } from '@openrfid/plugin-api';
+
+/**
+ * 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 RestPlugin implements IPlugin {
+    server: FastifyInstance | null;
+    private context;
+    getMetadata(): PluginMetadata;
+    initialize(context: PluginContext): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+/**
+ * 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 function readerRoutes(fastify: FastifyInstance, context: PluginContext): Promise<void>;
+
+/**
+ * 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 function tagRoutes(fastify: FastifyInstance, context: PluginContext): Promise<void>;
+
+/**
+ * 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 function eventRoutes(fastify: FastifyInstance, context: PluginContext): Promise<void>;
+
+export { RestPlugin, eventRoutes, readerRoutes, tagRoutes };

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import { FastifyInstance } from 'fastify';
+import { IPlugin, PluginMetadata, PluginContext } from '@openrfid/plugin-api';
+
+/**
+ * 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 RestPlugin implements IPlugin {
+    server: FastifyInstance | null;
+    private context;
+    getMetadata(): PluginMetadata;
+    initialize(context: PluginContext): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+/**
+ * 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 function readerRoutes(fastify: FastifyInstance, context: PluginContext): Promise<void>;
+
+/**
+ * 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 function tagRoutes(fastify: FastifyInstance, context: PluginContext): Promise<void>;
+
+/**
+ * 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 function eventRoutes(fastify: FastifyInstance, context: PluginContext): Promise<void>;
+
+export { RestPlugin, eventRoutes, readerRoutes, tagRoutes };

package/dist/index.js

@@ -0,0 +1,246 @@
+"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 index_exports = {};
+__export(index_exports, {
+  RestPlugin: () => RestPlugin,
+  eventRoutes: () => eventRoutes,
+  readerRoutes: () => readerRoutes,
+  tagRoutes: () => tagRoutes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/rest-plugin.ts
+var import_fastify = __toESM(require("fastify"));
+
+// src/routes/readers.ts
+var import_readers = require("@openrfid/readers");
+async function readerRoutes(fastify, context) {
+  fastify.get("/readers", async () => {
+    return context.simulator.getAllReaders().map((r) => r.toJSON());
+  });
+  fastify.get("/readers/:id", async (request, reply) => {
+    const reader = context.simulator.getReader(request.params.id);
+    if (!reader) {
+      return reply.status(404).send({ error: "Reader not found" });
+    }
+    return reader.toJSON();
+  });
+  fastify.post(
+    "/readers",
+    async (request, reply) => {
+      const { name, vendor, model, ip, port } = request.body || {};
+      if (!name) {
+        return reply.status(400).send({ error: "Reader name is required" });
+      }
+      const reader = new import_readers.VirtualReader({ name, vendor, model, ip, port });
+      context.simulator.addReader(reader);
+      return reply.status(201).send(reader.toJSON());
+    }
+  );
+  fastify.delete("/readers/:id", async (request, reply) => {
+    context.simulator.removeReader(request.params.id);
+    return { success: true };
+  });
+  fastify.post("/readers/:id/start", async (request, reply) => {
+    try {
+      context.simulator.startReader(request.params.id);
+      return { success: true, message: "Reader started" };
+    } catch (err) {
+      return reply.status(400).send({ error: err.message });
+    }
+  });
+  fastify.post("/readers/:id/stop", async (request, reply) => {
+    context.simulator.stopReader(request.params.id);
+    return { success: true, message: "Reader stopped" };
+  });
+}
+
+// src/routes/tags.ts
+var import_tags = require("@openrfid/tags");
+async function tagRoutes(fastify, context) {
+  fastify.get("/tags", async () => {
+    return context.simulator.getAllTags().map((t) => t.toJSON());
+  });
+  fastify.post("/tags", async (request, reply) => {
+    const { epc, tid, userMemory } = request.body || {};
+    if (!epc) {
+      return reply.status(400).send({ error: "EPC is required" });
+    }
+    const tag = new import_tags.Tag({ epc, tid, userMemory });
+    context.simulator.addTag(tag);
+    return reply.status(201).send(tag.toJSON());
+  });
+  fastify.post(
+    "/tags/generate",
+    async (request, reply) => {
+      const { count = 10, type = "sequential", header } = request.body || {};
+      const batch = import_tags.TagGenerator.generateBatch({ count, type, header });
+      context.simulator.addTagBatch(batch);
+      return reply.status(201).send(batch.map((t) => t.toJSON()));
+    }
+  );
+  fastify.delete("/tags/:epc", async (request, reply) => {
+    context.simulator.removeTag(request.params.epc);
+    return { success: true };
+  });
+}
+
+// src/routes/events.ts
+async function eventRoutes(fastify, context) {
+  fastify.get("/events", async (request) => {
+    if (!context.storage) return [];
+    const { limit, offset, date, from, to, readerId, epc, protocol } = request.query;
+    return context.storage.getEvents({
+      limit: limit ? parseInt(limit, 10) : 1e3,
+      offset: offset ? parseInt(offset, 10) : 0,
+      date,
+      from,
+      to,
+      readerId,
+      epc,
+      protocol
+    });
+  });
+  fastify.get("/events/stats", async (_request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    return context.storage.getEventStats();
+  });
+  fastify.get("/events/dates", async (_request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    return context.storage.getEventDates();
+  });
+  fastify.get("/events/dates/:date", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    const { date } = request.params;
+    const limit = parseInt(request.query.limit || "1000", 10);
+    const offset = parseInt(request.query.offset || "0", 10);
+    return context.storage.getEventsByDate(date, limit, offset);
+  });
+  fastify.get("/events/export", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    const events = await context.storage.getEvents({
+      ...request.query,
+      limit: 1e5
+      // large export cap
+    });
+    const csvHeader = "id,date,timestamp,readerId,antennaId,epc,rssi,protocol\n";
+    const csvBody = events.map((e) => `${e.id},${e.date},${e.timestamp},${e.readerId},${e.antennaId},${e.epc},${e.rssi},${e.protocol}`).join("\n");
+    const filename = `openrfid-events-${request.query.date || "export"}.csv`;
+    reply.header("Content-Type", "text/csv").header("Content-Disposition", `attachment; filename="${filename}"`).send(csvHeader + csvBody);
+  });
+  fastify.delete("/events/dates/:date", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    const result = await context.storage.deleteEventsByDate(request.params.date);
+    return { success: true, ...result };
+  });
+  fastify.delete("/events", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    if (request.query.confirm !== "true") {
+      return reply.status(400).send({ error: "Pass ?confirm=true to clear all events" });
+    }
+    const result = await context.storage.clearAllEvents();
+    return { success: true, ...result };
+  });
+  fastify.delete("/storage", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    if (request.query.confirm !== "WIPE") {
+      return reply.status(400).send({ error: "Pass ?confirm=WIPE to clear all data" });
+    }
+    await context.storage.clearAllData();
+    return { success: true, message: "All data cleared" };
+  });
+  fastify.get("/health", async () => {
+    return { status: "OK", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  });
+  fastify.get("/status", async () => {
+    const readers = context.simulator.getAllReaders();
+    const tags = context.simulator.getAllTags();
+    const stats = context.storage ? await context.storage.getEventStats() : null;
+    return {
+      uptime: process.uptime ? Math.floor(process.uptime()) : null,
+      readers: {
+        total: readers.length,
+        online: readers.filter((r) => r.status === "ONLINE").length,
+        offline: readers.filter((r) => r.status === "OFFLINE").length
+      },
+      tags: { total: tags.length },
+      events: stats ? { totalLogged: stats.totalEvents, totalDays: stats.totalDays } : { totalLogged: 0, totalDays: 0 }
+    };
+  });
+}
+
+// src/rest-plugin.ts
+var RestPlugin = class {
+  server = null;
+  context = null;
+  getMetadata() {
+    return {
+      name: "rest-api",
+      version: "0.1.0",
+      description: "Auto-generated REST API server plugin for OpenRFID Simulator"
+    };
+  }
+  async initialize(context) {
+    this.context = context;
+    this.server = (0, import_fastify.default)({ logger: false });
+    await readerRoutes(this.server, this.context);
+    await tagRoutes(this.server, this.context);
+    await eventRoutes(this.server, this.context);
+  }
+  async start() {
+    if (!this.server || !this.context) return;
+    const port = this.context.config.get("server.port") || 3e3;
+    const host = this.context.config.get("server.host") || "0.0.0.0";
+    try {
+      await this.server.listen({ port, host });
+      this.context.logger.info(`REST API plugin listening on http://${host}:${port}`);
+    } catch (err) {
+      this.context.logger.error("Failed to start REST API plugin", err);
+      throw err;
+    }
+  }
+  async stop() {
+    if (this.server) {
+      await this.server.close();
+      this.server = null;
+    }
+  }
+  async dispose() {
+    await this.stop();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RestPlugin,
+  eventRoutes,
+  readerRoutes,
+  tagRoutes
+});

package/dist/index.mjs

@@ -0,0 +1,206 @@
+// src/rest-plugin.ts
+import Fastify from "fastify";
+
+// src/routes/readers.ts
+import { VirtualReader } from "@openrfid/readers";
+async function readerRoutes(fastify, context) {
+  fastify.get("/readers", async () => {
+    return context.simulator.getAllReaders().map((r) => r.toJSON());
+  });
+  fastify.get("/readers/:id", async (request, reply) => {
+    const reader = context.simulator.getReader(request.params.id);
+    if (!reader) {
+      return reply.status(404).send({ error: "Reader not found" });
+    }
+    return reader.toJSON();
+  });
+  fastify.post(
+    "/readers",
+    async (request, reply) => {
+      const { name, vendor, model, ip, port } = request.body || {};
+      if (!name) {
+        return reply.status(400).send({ error: "Reader name is required" });
+      }
+      const reader = new VirtualReader({ name, vendor, model, ip, port });
+      context.simulator.addReader(reader);
+      return reply.status(201).send(reader.toJSON());
+    }
+  );
+  fastify.delete("/readers/:id", async (request, reply) => {
+    context.simulator.removeReader(request.params.id);
+    return { success: true };
+  });
+  fastify.post("/readers/:id/start", async (request, reply) => {
+    try {
+      context.simulator.startReader(request.params.id);
+      return { success: true, message: "Reader started" };
+    } catch (err) {
+      return reply.status(400).send({ error: err.message });
+    }
+  });
+  fastify.post("/readers/:id/stop", async (request, reply) => {
+    context.simulator.stopReader(request.params.id);
+    return { success: true, message: "Reader stopped" };
+  });
+}
+
+// src/routes/tags.ts
+import { Tag, TagGenerator } from "@openrfid/tags";
+async function tagRoutes(fastify, context) {
+  fastify.get("/tags", async () => {
+    return context.simulator.getAllTags().map((t) => t.toJSON());
+  });
+  fastify.post("/tags", async (request, reply) => {
+    const { epc, tid, userMemory } = request.body || {};
+    if (!epc) {
+      return reply.status(400).send({ error: "EPC is required" });
+    }
+    const tag = new Tag({ epc, tid, userMemory });
+    context.simulator.addTag(tag);
+    return reply.status(201).send(tag.toJSON());
+  });
+  fastify.post(
+    "/tags/generate",
+    async (request, reply) => {
+      const { count = 10, type = "sequential", header } = request.body || {};
+      const batch = TagGenerator.generateBatch({ count, type, header });
+      context.simulator.addTagBatch(batch);
+      return reply.status(201).send(batch.map((t) => t.toJSON()));
+    }
+  );
+  fastify.delete("/tags/:epc", async (request, reply) => {
+    context.simulator.removeTag(request.params.epc);
+    return { success: true };
+  });
+}
+
+// src/routes/events.ts
+async function eventRoutes(fastify, context) {
+  fastify.get("/events", async (request) => {
+    if (!context.storage) return [];
+    const { limit, offset, date, from, to, readerId, epc, protocol } = request.query;
+    return context.storage.getEvents({
+      limit: limit ? parseInt(limit, 10) : 1e3,
+      offset: offset ? parseInt(offset, 10) : 0,
+      date,
+      from,
+      to,
+      readerId,
+      epc,
+      protocol
+    });
+  });
+  fastify.get("/events/stats", async (_request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    return context.storage.getEventStats();
+  });
+  fastify.get("/events/dates", async (_request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    return context.storage.getEventDates();
+  });
+  fastify.get("/events/dates/:date", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    const { date } = request.params;
+    const limit = parseInt(request.query.limit || "1000", 10);
+    const offset = parseInt(request.query.offset || "0", 10);
+    return context.storage.getEventsByDate(date, limit, offset);
+  });
+  fastify.get("/events/export", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    const events = await context.storage.getEvents({
+      ...request.query,
+      limit: 1e5
+      // large export cap
+    });
+    const csvHeader = "id,date,timestamp,readerId,antennaId,epc,rssi,protocol\n";
+    const csvBody = events.map((e) => `${e.id},${e.date},${e.timestamp},${e.readerId},${e.antennaId},${e.epc},${e.rssi},${e.protocol}`).join("\n");
+    const filename = `openrfid-events-${request.query.date || "export"}.csv`;
+    reply.header("Content-Type", "text/csv").header("Content-Disposition", `attachment; filename="${filename}"`).send(csvHeader + csvBody);
+  });
+  fastify.delete("/events/dates/:date", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    const result = await context.storage.deleteEventsByDate(request.params.date);
+    return { success: true, ...result };
+  });
+  fastify.delete("/events", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    if (request.query.confirm !== "true") {
+      return reply.status(400).send({ error: "Pass ?confirm=true to clear all events" });
+    }
+    const result = await context.storage.clearAllEvents();
+    return { success: true, ...result };
+  });
+  fastify.delete("/storage", async (request, reply) => {
+    if (!context.storage) return reply.status(503).send({ error: "Storage not available" });
+    if (request.query.confirm !== "WIPE") {
+      return reply.status(400).send({ error: "Pass ?confirm=WIPE to clear all data" });
+    }
+    await context.storage.clearAllData();
+    return { success: true, message: "All data cleared" };
+  });
+  fastify.get("/health", async () => {
+    return { status: "OK", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  });
+  fastify.get("/status", async () => {
+    const readers = context.simulator.getAllReaders();
+    const tags = context.simulator.getAllTags();
+    const stats = context.storage ? await context.storage.getEventStats() : null;
+    return {
+      uptime: process.uptime ? Math.floor(process.uptime()) : null,
+      readers: {
+        total: readers.length,
+        online: readers.filter((r) => r.status === "ONLINE").length,
+        offline: readers.filter((r) => r.status === "OFFLINE").length
+      },
+      tags: { total: tags.length },
+      events: stats ? { totalLogged: stats.totalEvents, totalDays: stats.totalDays } : { totalLogged: 0, totalDays: 0 }
+    };
+  });
+}
+
+// src/rest-plugin.ts
+var RestPlugin = class {
+  server = null;
+  context = null;
+  getMetadata() {
+    return {
+      name: "rest-api",
+      version: "0.1.0",
+      description: "Auto-generated REST API server plugin for OpenRFID Simulator"
+    };
+  }
+  async initialize(context) {
+    this.context = context;
+    this.server = Fastify({ logger: false });
+    await readerRoutes(this.server, this.context);
+    await tagRoutes(this.server, this.context);
+    await eventRoutes(this.server, this.context);
+  }
+  async start() {
+    if (!this.server || !this.context) return;
+    const port = this.context.config.get("server.port") || 3e3;
+    const host = this.context.config.get("server.host") || "0.0.0.0";
+    try {
+      await this.server.listen({ port, host });
+      this.context.logger.info(`REST API plugin listening on http://${host}:${port}`);
+    } catch (err) {
+      this.context.logger.error("Failed to start REST API plugin", err);
+      throw err;
+    }
+  }
+  async stop() {
+    if (this.server) {
+      await this.server.close();
+      this.server = null;
+    }
+  }
+  async dispose() {
+    await this.stop();
+  }
+};
+export {
+  RestPlugin,
+  eventRoutes,
+  readerRoutes,
+  tagRoutes
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@openrfid/rest",
+  "version": "0.1.0",
+  "description": "Fastify HTTP REST API plugin for OpenRFID Simulator.",
+  "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": {
+    "fastify": "^4.26.2",
+    "@openrfid/core": "0.1.0",
+    "@openrfid/plugin-api": "0.1.0",
+    "@openrfid/simulator": "0.1.0",
+    "@openrfid/readers": "0.1.0",
+    "@openrfid/tags": "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"
+  }
+}