@moltium/world-core 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -0,0 +1,2195 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/persistence/adapters/SQLiteAdapter.ts
+var SQLiteAdapter_exports = {};
+__export(SQLiteAdapter_exports, {
+  SQLiteAdapter: () => SQLiteAdapter
+});
+var import_better_sqlite3, SQLiteAdapter;
+var init_SQLiteAdapter = __esm({
+  "src/persistence/adapters/SQLiteAdapter.ts"() {
+    "use strict";
+    import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+    SQLiteAdapter = class {
+      constructor(config) {
+        this.config = config;
+      }
+      db;
+      async connect() {
+        this.db = new import_better_sqlite3.default(this.config.filename);
+        this.initSchema();
+      }
+      initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS world_state (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        phase TEXT NOT NULL,
+        tick INTEGER NOT NULL,
+        round INTEGER NOT NULL,
+        timestamp INTEGER NOT NULL,
+        metadata TEXT
+      );
+      
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        agent_url TEXT,
+        timestamp INTEGER NOT NULL,
+        data TEXT
+      );
+      
+      CREATE TABLE IF NOT EXISTS agents (
+        url TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        protocol_version TEXT NOT NULL,
+        skills TEXT NOT NULL,
+        capabilities TEXT NOT NULL,
+        joined_at INTEGER NOT NULL,
+        role TEXT,
+        metadata TEXT,
+        wallet_address TEXT
+      );
+      
+      CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_agent ON events(agent_url);
+    `);
+      }
+      async saveState(state) {
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO world_state (id, phase, tick, round, timestamp, metadata)
+      VALUES (1, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(
+          state.phase,
+          state.tick,
+          state.round,
+          state.timestamp,
+          JSON.stringify(state.metadata)
+        );
+      }
+      async loadState() {
+        const stmt = this.db.prepare("SELECT * FROM world_state WHERE id = 1");
+        const row = stmt.get();
+        if (!row) return null;
+        return {
+          phase: row.phase,
+          tick: row.tick,
+          round: row.round,
+          timestamp: row.timestamp,
+          metadata: JSON.parse(row.metadata || "{}")
+        };
+      }
+      async saveEvent(event) {
+        const stmt = this.db.prepare(`
+      INSERT INTO events (id, type, agent_url, timestamp, data)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(
+          event.id,
+          event.type,
+          event.agentUrl || null,
+          event.timestamp,
+          JSON.stringify(event.data || {})
+        );
+      }
+      async getEvents(filter) {
+        let query = "SELECT * FROM events WHERE 1=1";
+        const params = [];
+        if (filter?.type) {
+          query += " AND type = ?";
+          params.push(filter.type);
+        }
+        if (filter?.agentUrl) {
+          query += " AND agent_url = ?";
+          params.push(filter.agentUrl);
+        }
+        if (filter?.fromTimestamp) {
+          query += " AND timestamp >= ?";
+          params.push(filter.fromTimestamp);
+        }
+        if (filter?.toTimestamp) {
+          query += " AND timestamp <= ?";
+          params.push(filter.toTimestamp);
+        }
+        query += " ORDER BY timestamp DESC";
+        if (filter?.limit) {
+          query += " LIMIT ?";
+          params.push(filter.limit);
+        }
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(...params);
+        return rows.map((row) => ({
+          id: row.id,
+          type: row.type,
+          timestamp: row.timestamp,
+          agentUrl: row.agent_url || void 0,
+          data: JSON.parse(row.data || "{}")
+        }));
+      }
+      async saveAgent(profile) {
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO agents 
+      (url, name, protocol_version, skills, capabilities, joined_at, role, metadata, wallet_address)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(
+          profile.url,
+          profile.name,
+          profile.protocolVersion,
+          JSON.stringify(profile.skills),
+          JSON.stringify(profile.capabilities),
+          profile.joinedAt,
+          profile.role || null,
+          JSON.stringify(profile.metadata || {}),
+          profile.walletAddress || null
+        );
+      }
+      async removeAgent(agentUrl) {
+        const stmt = this.db.prepare("DELETE FROM agents WHERE url = ?");
+        stmt.run(agentUrl);
+      }
+      async getAgents() {
+        const stmt = this.db.prepare("SELECT * FROM agents ORDER BY joined_at ASC");
+        const rows = stmt.all();
+        return rows.map((row) => ({
+          url: row.url,
+          name: row.name,
+          protocolVersion: row.protocol_version,
+          skills: JSON.parse(row.skills),
+          capabilities: JSON.parse(row.capabilities),
+          joinedAt: row.joined_at,
+          role: row.role || void 0,
+          metadata: JSON.parse(row.metadata || "{}"),
+          walletAddress: row.wallet_address || void 0
+        }));
+      }
+      async getAgent(agentUrl) {
+        const stmt = this.db.prepare("SELECT * FROM agents WHERE url = ?");
+        const row = stmt.get(agentUrl);
+        if (!row) return null;
+        return {
+          url: row.url,
+          name: row.name,
+          protocolVersion: row.protocol_version,
+          skills: JSON.parse(row.skills),
+          capabilities: JSON.parse(row.capabilities),
+          joinedAt: row.joined_at,
+          role: row.role || void 0,
+          metadata: JSON.parse(row.metadata || "{}"),
+          walletAddress: row.wallet_address || void 0
+        };
+      }
+      async disconnect() {
+        this.db.close();
+      }
+      async healthCheck() {
+        try {
+          const stmt = this.db.prepare("SELECT 1");
+          stmt.get();
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async clear() {
+        this.db.exec(`
+      DELETE FROM world_state;
+      DELETE FROM events;
+      DELETE FROM agents;
+    `);
+      }
+    };
+  }
+});
+
+// src/persistence/adapters/PostgresAdapter.ts
+var PostgresAdapter_exports = {};
+__export(PostgresAdapter_exports, {
+  PostgresAdapter: () => PostgresAdapter
+});
+var import_pg, Pool, PostgresAdapter;
+var init_PostgresAdapter = __esm({
+  "src/persistence/adapters/PostgresAdapter.ts"() {
+    "use strict";
+    import_pg = __toESM(require("pg"), 1);
+    ({ Pool } = import_pg.default);
+    PostgresAdapter = class {
+      constructor(config) {
+        this.config = config;
+        this.pool = new Pool({
+          host: config.host,
+          port: config.port || 5432,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+          ssl: config.ssl ? { rejectUnauthorized: false } : void 0,
+          max: config.max || 10
+        });
+      }
+      pool;
+      connected = false;
+      async connect() {
+        try {
+          await this.pool.query("SELECT NOW()");
+          await this.initSchema();
+          this.connected = true;
+        } catch (error) {
+          throw new Error(`PostgreSQL connection failed: ${error.message}`);
+        }
+      }
+      async initSchema() {
+        const client = await this.pool.connect();
+        try {
+          await client.query("BEGIN");
+          await client.query(`
+        CREATE TABLE IF NOT EXISTS world_state (
+          id SERIAL PRIMARY KEY,
+          phase VARCHAR(50) NOT NULL,
+          tick INTEGER NOT NULL,
+          round INTEGER NOT NULL,
+          timestamp BIGINT NOT NULL,
+          metadata JSONB DEFAULT '{}'::jsonb,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+          await client.query(`
+        CREATE TABLE IF NOT EXISTS world_events (
+          id VARCHAR(255) PRIMARY KEY,
+          type VARCHAR(100) NOT NULL,
+          timestamp BIGINT NOT NULL,
+          agent_url VARCHAR(500),
+          data JSONB DEFAULT '{}'::jsonb,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+          await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_events_type ON world_events(type)
+      `);
+          await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_events_timestamp ON world_events(timestamp)
+      `);
+          await client.query(`
+        CREATE TABLE IF NOT EXISTS agent_profiles (
+          url VARCHAR(500) PRIMARY KEY,
+          name VARCHAR(255) NOT NULL,
+          protocol_version VARCHAR(50) NOT NULL,
+          skills JSONB NOT NULL,
+          capabilities JSONB NOT NULL,
+          joined_at BIGINT NOT NULL,
+          role VARCHAR(100),
+          metadata JSONB DEFAULT '{}'::jsonb,
+          wallet_address VARCHAR(255),
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+          await client.query("COMMIT");
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        } finally {
+          client.release();
+        }
+      }
+      async saveState(state) {
+        await this.pool.query(
+          `INSERT INTO world_state (phase, tick, round, timestamp, metadata) 
+       VALUES ($1, $2, $3, $4, $5)`,
+          [state.phase, state.tick, state.round, state.timestamp, JSON.stringify(state.metadata)]
+        );
+      }
+      async loadState() {
+        const result = await this.pool.query(
+          "SELECT * FROM world_state ORDER BY id DESC LIMIT 1"
+        );
+        if (result.rows.length === 0) {
+          return null;
+        }
+        const row = result.rows[0];
+        return {
+          phase: row.phase,
+          tick: row.tick,
+          round: row.round,
+          timestamp: parseInt(row.timestamp),
+          metadata: row.metadata
+        };
+      }
+      async saveEvent(event) {
+        await this.pool.query(
+          `INSERT INTO world_events (id, type, timestamp, agent_url, data) 
+       VALUES ($1, $2, $3, $4, $5)`,
+          [event.id, event.type, event.timestamp, event.agentUrl || null, JSON.stringify(event.data)]
+        );
+      }
+      async getEvents(filter) {
+        let query = "SELECT * FROM world_events WHERE 1=1";
+        const params = [];
+        let paramCount = 1;
+        if (filter?.type) {
+          query += ` AND type = $${paramCount++}`;
+          params.push(filter.type);
+        }
+        if (filter?.agentUrl) {
+          query += ` AND agent_url = $${paramCount++}`;
+          params.push(filter.agentUrl);
+        }
+        if (filter?.since) {
+          query += ` AND timestamp >= $${paramCount++}`;
+          params.push(filter.since);
+        }
+        if (filter?.until) {
+          query += ` AND timestamp <= $${paramCount++}`;
+          params.push(filter.until);
+        }
+        query += " ORDER BY timestamp DESC";
+        if (filter?.limit) {
+          query += ` LIMIT $${paramCount++}`;
+          params.push(filter.limit);
+        }
+        const result = await this.pool.query(query, params);
+        return result.rows.map((row) => ({
+          id: row.id,
+          type: row.type,
+          timestamp: parseInt(row.timestamp),
+          agentUrl: row.agent_url,
+          data: row.data
+        }));
+      }
+      async saveAgent(profile) {
+        await this.pool.query(
+          `INSERT INTO agent_profiles 
+       (url, name, protocol_version, skills, capabilities, joined_at, role, metadata, wallet_address) 
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+       ON CONFLICT (url) DO UPDATE SET
+       name = EXCLUDED.name,
+       protocol_version = EXCLUDED.protocol_version,
+       skills = EXCLUDED.skills,
+       capabilities = EXCLUDED.capabilities,
+       role = EXCLUDED.role,
+       metadata = EXCLUDED.metadata,
+       wallet_address = EXCLUDED.wallet_address`,
+          [
+            profile.url,
+            profile.name,
+            profile.protocolVersion,
+            JSON.stringify(profile.skills),
+            JSON.stringify(profile.capabilities),
+            profile.joinedAt,
+            profile.role || null,
+            JSON.stringify(profile.metadata || {}),
+            profile.walletAddress || null
+          ]
+        );
+      }
+      async removeAgent(agentUrl) {
+        await this.pool.query("DELETE FROM agent_profiles WHERE url = $1", [agentUrl]);
+      }
+      async getAgents() {
+        const result = await this.pool.query(
+          "SELECT * FROM agent_profiles ORDER BY joined_at ASC"
+        );
+        return result.rows.map((row) => ({
+          url: row.url,
+          name: row.name,
+          protocolVersion: row.protocol_version,
+          skills: row.skills,
+          capabilities: row.capabilities,
+          joinedAt: parseInt(row.joined_at),
+          role: row.role,
+          metadata: row.metadata,
+          walletAddress: row.wallet_address
+        }));
+      }
+      async getAgent(agentUrl) {
+        const result = await this.pool.query(
+          "SELECT * FROM agent_profiles WHERE url = $1",
+          [agentUrl]
+        );
+        if (result.rows.length === 0) {
+          return null;
+        }
+        const row = result.rows[0];
+        return {
+          url: row.url,
+          name: row.name,
+          protocolVersion: row.protocol_version,
+          skills: row.skills,
+          capabilities: row.capabilities,
+          joinedAt: parseInt(row.joined_at),
+          role: row.role,
+          metadata: row.metadata,
+          walletAddress: row.wallet_address
+        };
+      }
+      async disconnect() {
+        await this.pool.end();
+        this.connected = false;
+      }
+      async healthCheck() {
+        try {
+          await this.pool.query("SELECT 1");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async clear() {
+        const client = await this.pool.connect();
+        try {
+          await client.query("BEGIN");
+          await client.query("TRUNCATE world_state, world_events, agent_profiles");
+          await client.query("COMMIT");
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        } finally {
+          client.release();
+        }
+      }
+    };
+  }
+});
+
+// src/persistence/adapters/RedisAdapter.ts
+var RedisAdapter_exports = {};
+__export(RedisAdapter_exports, {
+  RedisAdapter: () => RedisAdapter
+});
+var import_ioredis, RedisAdapter;
+var init_RedisAdapter = __esm({
+  "src/persistence/adapters/RedisAdapter.ts"() {
+    "use strict";
+    import_ioredis = require("ioredis");
+    RedisAdapter = class {
+      constructor(config) {
+        this.config = config;
+        this.keyPrefix = config.keyPrefix || "world:";
+        this.client = new import_ioredis.Redis({
+          host: config.host,
+          port: config.port || 6379,
+          password: config.password,
+          db: config.db || 0
+        });
+      }
+      client;
+      connected = false;
+      keyPrefix;
+      async connect() {
+        try {
+          await this.client.ping();
+          this.connected = true;
+        } catch (error) {
+          throw new Error(`Redis connection failed: ${error.message}`);
+        }
+      }
+      async saveState(state) {
+        const key = `${this.keyPrefix}state`;
+        await this.client.set(key, JSON.stringify(state));
+        const historyKey = `${this.keyPrefix}state:history`;
+        await this.client.zadd(historyKey, state.timestamp, JSON.stringify(state));
+      }
+      async loadState() {
+        const key = `${this.keyPrefix}state`;
+        const data = await this.client.get(key);
+        if (!data) {
+          return null;
+        }
+        return JSON.parse(data);
+      }
+      async saveEvent(event) {
+        const eventsKey = `${this.keyPrefix}events`;
+        await this.client.zadd(eventsKey, event.timestamp, JSON.stringify(event));
+        const typeKey = `${this.keyPrefix}events:type:${event.type}`;
+        await this.client.zadd(typeKey, event.timestamp, JSON.stringify(event));
+        if (event.agentUrl) {
+          const agentKey = `${this.keyPrefix}events:agent:${event.agentUrl}`;
+          await this.client.zadd(agentKey, event.timestamp, JSON.stringify(event));
+        }
+      }
+      async getEvents(filter) {
+        let key = `${this.keyPrefix}events`;
+        if (filter?.type) {
+          key = `${this.keyPrefix}events:type:${filter.type}`;
+        } else if (filter?.agentUrl) {
+          key = `${this.keyPrefix}events:agent:${filter.agentUrl}`;
+        }
+        const min = filter?.since || "-inf";
+        const max = filter?.until || "+inf";
+        const count = filter?.limit || -1;
+        const results = await this.client.zrevrangebyscore(
+          key,
+          max,
+          min,
+          "LIMIT",
+          0,
+          count === -1 ? 100 : count
+        );
+        return results.map((r) => JSON.parse(r));
+      }
+      async saveAgent(profile) {
+        const key = `${this.keyPrefix}agent:${profile.url}`;
+        await this.client.set(key, JSON.stringify(profile));
+        const agentsKey = `${this.keyPrefix}agents`;
+        await this.client.sadd(agentsKey, profile.url);
+      }
+      async removeAgent(agentUrl) {
+        const key = `${this.keyPrefix}agent:${agentUrl}`;
+        await this.client.del(key);
+        const agentsKey = `${this.keyPrefix}agents`;
+        await this.client.srem(agentsKey, agentUrl);
+      }
+      async getAgents() {
+        const agentsKey = `${this.keyPrefix}agents`;
+        const urls = await this.client.smembers(agentsKey);
+        if (urls.length === 0) {
+          return [];
+        }
+        const keys = urls.map((url) => `${this.keyPrefix}agent:${url}`);
+        const results = await this.client.mget(...keys);
+        return results.filter((r) => r !== null).map((r) => JSON.parse(r));
+      }
+      async getAgent(agentUrl) {
+        const key = `${this.keyPrefix}agent:${agentUrl}`;
+        const data = await this.client.get(key);
+        if (!data) {
+          return null;
+        }
+        return JSON.parse(data);
+      }
+      async disconnect() {
+        await this.client.quit();
+        this.connected = false;
+      }
+      async healthCheck() {
+        try {
+          await this.client.ping();
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async clear() {
+        const pattern = `${this.keyPrefix}*`;
+        const keys = await this.client.keys(pattern);
+        if (keys.length > 0) {
+          await this.client.del(...keys);
+        }
+      }
+    };
+  }
+});
+
+// src/persistence/adapters/MongoAdapter.ts
+var MongoAdapter_exports = {};
+__export(MongoAdapter_exports, {
+  MongoAdapter: () => MongoAdapter
+});
+var import_mongodb, MongoAdapter;
+var init_MongoAdapter = __esm({
+  "src/persistence/adapters/MongoAdapter.ts"() {
+    "use strict";
+    import_mongodb = require("mongodb");
+    MongoAdapter = class {
+      constructor(config) {
+        this.config = config;
+        this.client = new import_mongodb.MongoClient(config.url, {
+          useUnifiedTopology: config.useUnifiedTopology !== false
+        });
+      }
+      client;
+      db;
+      stateCollection;
+      eventsCollection;
+      agentsCollection;
+      connected = false;
+      async connect() {
+        try {
+          await this.client.connect();
+          this.db = this.client.db(this.config.database);
+          this.stateCollection = this.db.collection("world_state");
+          this.eventsCollection = this.db.collection("world_events");
+          this.agentsCollection = this.db.collection("agent_profiles");
+          await this.initIndexes();
+          this.connected = true;
+        } catch (error) {
+          throw new Error(`MongoDB connection failed: ${error.message}`);
+        }
+      }
+      async initIndexes() {
+        await this.eventsCollection.createIndex({ type: 1 });
+        await this.eventsCollection.createIndex({ timestamp: -1 });
+        await this.eventsCollection.createIndex({ agentUrl: 1 });
+        await this.eventsCollection.createIndex({ type: 1, timestamp: -1 });
+        await this.agentsCollection.createIndex({ url: 1 }, { unique: true });
+        await this.agentsCollection.createIndex({ joinedAt: 1 });
+        await this.stateCollection.createIndex({ timestamp: -1 });
+      }
+      async saveState(state) {
+        await this.stateCollection.insertOne({
+          ...state,
+          _createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+      async loadState() {
+        const doc = await this.stateCollection.findOne(
+          {},
+          { sort: { timestamp: -1 } }
+        );
+        if (!doc) {
+          return null;
+        }
+        const { _id, _createdAt, ...state } = doc;
+        return state;
+      }
+      async saveEvent(event) {
+        await this.eventsCollection.insertOne({
+          _id: event.id,
+          ...event,
+          _createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+      async getEvents(filter) {
+        const query = {};
+        if (filter?.type) {
+          query.type = filter.type;
+        }
+        if (filter?.agentUrl) {
+          query.agentUrl = filter.agentUrl;
+        }
+        if (filter?.since || filter?.until) {
+          query.timestamp = {};
+          if (filter.since) {
+            query.timestamp.$gte = filter.since;
+          }
+          if (filter.until) {
+            query.timestamp.$lte = filter.until;
+          }
+        }
+        const cursor = this.eventsCollection.find(query).sort({ timestamp: -1 });
+        if (filter?.limit) {
+          cursor.limit(filter.limit);
+        }
+        const docs = await cursor.toArray();
+        return docs.map((doc) => {
+          const { _id, _createdAt, ...event } = doc;
+          return event;
+        });
+      }
+      async saveAgent(profile) {
+        await this.agentsCollection.updateOne(
+          { url: profile.url },
+          { $set: { ...profile, _updatedAt: /* @__PURE__ */ new Date() } },
+          { upsert: true }
+        );
+      }
+      async removeAgent(agentUrl) {
+        await this.agentsCollection.deleteOne({ url: agentUrl });
+      }
+      async getAgents() {
+        const docs = await this.agentsCollection.find({}).sort({ joinedAt: 1 }).toArray();
+        return docs.map((doc) => {
+          const { _id, _updatedAt, ...profile } = doc;
+          return profile;
+        });
+      }
+      async getAgent(agentUrl) {
+        const doc = await this.agentsCollection.findOne({ url: agentUrl });
+        if (!doc) {
+          return null;
+        }
+        const { _id, _updatedAt, ...profile } = doc;
+        return profile;
+      }
+      async disconnect() {
+        await this.client.close();
+        this.connected = false;
+      }
+      async healthCheck() {
+        try {
+          await this.db.admin().ping();
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async clear() {
+        await Promise.all([
+          this.stateCollection.deleteMany({}),
+          this.eventsCollection.deleteMany({}),
+          this.agentsCollection.deleteMany({})
+        ]);
+      }
+    };
+  }
+});
+
+// src/persistence/adapters/LevelDBAdapter.ts
+var LevelDBAdapter_exports = {};
+__export(LevelDBAdapter_exports, {
+  LevelDBAdapter: () => LevelDBAdapter
+});
+var import_level, LevelDBAdapter;
+var init_LevelDBAdapter = __esm({
+  "src/persistence/adapters/LevelDBAdapter.ts"() {
+    "use strict";
+    import_level = require("level");
+    LevelDBAdapter = class {
+      constructor(config) {
+        this.config = config;
+      }
+      db;
+      connected = false;
+      async connect() {
+        try {
+          this.db = new import_level.Level(this.config.path, {
+            valueEncoding: "json"
+          });
+          await this.db.open();
+          this.connected = true;
+        } catch (error) {
+          throw new Error(`LevelDB connection failed: ${error.message}`);
+        }
+      }
+      async saveState(state) {
+        await this.db.put("state:current", JSON.stringify(state));
+        const historyKey = `state:history:${state.timestamp}`;
+        await this.db.put(historyKey, JSON.stringify(state));
+      }
+      async loadState() {
+        try {
+          const data = await this.db.get("state:current");
+          return JSON.parse(data);
+        } catch (error) {
+          if (error.code === "LEVEL_NOT_FOUND") {
+            return null;
+          }
+          throw error;
+        }
+      }
+      async saveEvent(event) {
+        const key = `event:${event.timestamp}:${event.id}`;
+        await this.db.put(key, JSON.stringify(event));
+        const typeKey = `event:type:${event.type}:${event.timestamp}:${event.id}`;
+        await this.db.put(typeKey, JSON.stringify(event));
+        if (event.agentUrl) {
+          const agentKey = `event:agent:${event.agentUrl}:${event.timestamp}:${event.id}`;
+          await this.db.put(agentKey, JSON.stringify(event));
+        }
+      }
+      async getEvents(filter) {
+        const events = [];
+        let prefix = "event:";
+        if (filter?.type) {
+          prefix = `event:type:${filter.type}:`;
+        } else if (filter?.agentUrl) {
+          prefix = `event:agent:${filter.agentUrl}:`;
+        }
+        const iterator = this.db.iterator({
+          gte: prefix,
+          lte: prefix + "\uFFFF",
+          reverse: true,
+          // Most recent first
+          limit: filter?.limit || -1
+        });
+        for await (const [key, value] of iterator) {
+          const event = JSON.parse(value);
+          if (filter?.since && event.timestamp < filter.since) continue;
+          if (filter?.until && event.timestamp > filter.until) continue;
+          if (filter?.type && !prefix.includes("type:") && event.type !== filter.type) {
+            continue;
+          }
+          if (filter?.agentUrl && !prefix.includes("agent:") && event.agentUrl !== filter.agentUrl) {
+            continue;
+          }
+          events.push(event);
+          if (filter?.limit && events.length >= filter.limit) {
+            break;
+          }
+        }
+        return events;
+      }
+      async saveAgent(profile) {
+        const key = `agent:${profile.url}`;
+        await this.db.put(key, JSON.stringify(profile));
+        const listKey = `agent:list:${profile.joinedAt}:${profile.url}`;
+        await this.db.put(listKey, profile.url);
+      }
+      async removeAgent(agentUrl) {
+        const key = `agent:${agentUrl}`;
+        try {
+          const data = await this.db.get(key);
+          const profile = JSON.parse(data);
+          await this.db.del(key);
+          const listKey = `agent:list:${profile.joinedAt}:${agentUrl}`;
+          await this.db.del(listKey);
+        } catch (error) {
+          if (error.code !== "LEVEL_NOT_FOUND") {
+            throw error;
+          }
+        }
+      }
+      async getAgents() {
+        const agents = [];
+        const iterator = this.db.iterator({
+          gte: "agent:list:",
+          lte: "agent:list:\uFFFF"
+        });
+        for await (const [key, agentUrl] of iterator) {
+          try {
+            const data = await this.db.get(`agent:${agentUrl}`);
+            agents.push(JSON.parse(data));
+          } catch (error) {
+            if (error.code !== "LEVEL_NOT_FOUND") {
+              throw error;
+            }
+          }
+        }
+        return agents;
+      }
+      async getAgent(agentUrl) {
+        try {
+          const data = await this.db.get(`agent:${agentUrl}`);
+          return JSON.parse(data);
+        } catch (error) {
+          if (error.code === "LEVEL_NOT_FOUND") {
+            return null;
+          }
+          throw error;
+        }
+      }
+      async disconnect() {
+        await this.db.close();
+        this.connected = false;
+      }
+      async healthCheck() {
+        try {
+          await this.db.get("health:check").catch(() => {
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async clear() {
+        await this.db.clear();
+      }
+    };
+  }
+});
+
+// src/logger.ts
+function createLogger(moduleName) {
+  return logger.child({ module: moduleName });
+}
+var import_winston, logLevel, logger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    import_winston = __toESM(require("winston"), 1);
+    logLevel = process.env.LOG_LEVEL || "info";
+    logger = import_winston.default.createLogger({
+      level: logLevel,
+      format: import_winston.default.format.combine(
+        import_winston.default.format.timestamp(),
+        import_winston.default.format.colorize(),
+        import_winston.default.format.printf(({ level, message, timestamp, ...meta }) => {
+          const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
+          return `${timestamp} [${level}] ${message}${metaStr}`;
+        })
+      ),
+      transports: [new import_winston.default.transports.Console()]
+    });
+  }
+});
+
+// src/discovery/CardFetcher.ts
+var CardFetcher_exports = {};
+__export(CardFetcher_exports, {
+  CardFetcher: () => CardFetcher,
+  normalizeAgentUrl: () => normalizeAgentUrl
+});
+function normalizeAgentUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.protocol}//${parsed.host}`;
+  } catch {
+    return url;
+  }
+}
+var logger2, CardFetcher;
+var init_CardFetcher = __esm({
+  "src/discovery/CardFetcher.ts"() {
+    "use strict";
+    init_logger();
+    logger2 = createLogger("CardFetcher");
+    CardFetcher = class {
+      /**
+       * Fetch an agent's card from their A2A endpoint.
+       * 
+       * @param agentUrl Base URL of the agent (e.g., http://localhost:3000)
+       * @returns Fetch result with card or error
+       */
+      async fetchCard(agentUrl) {
+        try {
+          const cardUrl = new URL("/.well-known/agent-card.json", agentUrl).toString();
+          logger2.debug(`Fetching agent card from ${cardUrl}`);
+          const response = await fetch(cardUrl, {
+            method: "GET",
+            headers: {
+              "Accept": "application/json",
+              "User-Agent": "@moltium/world-core/0.1.0"
+            },
+            signal: AbortSignal.timeout(5e3)
+            // 5 second timeout
+          });
+          if (!response.ok) {
+            return {
+              success: false,
+              error: `HTTP ${response.status}: ${response.statusText}`
+            };
+          }
+          const card = await response.json();
+          if (!card.name || !card.protocolVersion || !card.url || !card.skills) {
+            return {
+              success: false,
+              error: "Invalid agent card: missing required fields"
+            };
+          }
+          logger2.info(`Successfully fetched card for agent: ${card.name}`, {
+            protocolVersion: card.protocolVersion,
+            skillCount: card.skills.length
+          });
+          return {
+            success: true,
+            card
+          };
+        } catch (error) {
+          logger2.error(`Failed to fetch agent card from ${agentUrl}:`, error.message);
+          return {
+            success: false,
+            error: error.message || "Unknown error"
+          };
+        }
+      }
+      /**
+       * Fetch multiple agent cards in parallel.
+       * 
+       * @param agentUrls Array of agent URLs
+       * @returns Array of fetch results
+       */
+      async fetchCards(agentUrls) {
+        logger2.info(`Fetching ${agentUrls.length} agent cards...`);
+        const results = await Promise.all(
+          agentUrls.map((url) => this.fetchCard(url))
+        );
+        const successCount = results.filter((r) => r.success).length;
+        logger2.info(`Fetched ${successCount}/${agentUrls.length} agent cards successfully`);
+        return results;
+      }
+      /**
+       * Verify that an agent card is valid for A2A protocol v0.3.0.
+       * 
+       * @param card Agent card to verify
+       * @returns True if valid
+       */
+      verifyCard(card) {
+        if (!card.name || !card.protocolVersion || !card.url || !card.skills) {
+          logger2.warn("Agent card missing required fields", { name: card.name });
+          return false;
+        }
+        if (!card.protocolVersion.startsWith("0.3")) {
+          logger2.warn("Agent card has incompatible protocol version", {
+            name: card.name,
+            version: card.protocolVersion
+          });
+          return false;
+        }
+        if (!Array.isArray(card.skills) || card.skills.length === 0) {
+          logger2.warn("Agent card has no skills", { name: card.name });
+          return false;
+        }
+        if (!card.capabilities || typeof card.capabilities !== "object") {
+          logger2.warn("Agent card missing capabilities", { name: card.name });
+          return false;
+        }
+        return true;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AdmissionRulesSchema: () => AdmissionRulesSchema,
+  AgentEvaluator: () => AgentEvaluator,
+  BlockchainClient: () => BlockchainClient,
+  BlockchainConfigSchema: () => BlockchainConfigSchema,
+  CardFetcher: () => CardFetcher,
+  InMemoryAdapter: () => InMemoryAdapter,
+  PersistenceConfigSchema: () => PersistenceConfigSchema,
+  TokenConfigSchema: () => TokenConfigSchema,
+  World: () => World,
+  WorldConfigSchema: () => WorldConfigSchema,
+  createLogger: () => createLogger,
+  createPersistence: () => createPersistence,
+  createWorldApp: () => createWorldApp,
+  isValidWorldConfig: () => isValidWorldConfig,
+  logger: () => logger,
+  normalizeAgentUrl: () => normalizeAgentUrl,
+  profileFromCard: () => profileFromCard,
+  startWorldServer: () => startWorldServer,
+  validateWorldConfig: () => validateWorldConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/types.ts
+function profileFromCard(card, walletAddress) {
+  return {
+    url: card.url,
+    name: card.name,
+    protocolVersion: card.protocolVersion,
+    skills: card.skills,
+    capabilities: {
+      streaming: card.capabilities.streaming ?? false,
+      pushNotifications: card.capabilities.pushNotifications ?? false,
+      stateTransitionHistory: card.capabilities.stateTransitionHistory
+    },
+    joinedAt: Date.now(),
+    walletAddress
+  };
+}
+
+// src/config/validator.ts
+var import_zod = require("zod");
+var AdmissionRulesSchema = import_zod.z.object({
+  maxAgents: import_zod.z.number().int().positive().optional(),
+  requiredSkills: import_zod.z.array(import_zod.z.string()).optional(),
+  requiredTags: import_zod.z.array(import_zod.z.string()).optional(),
+  minProtocolVersion: import_zod.z.string().optional(),
+  customEvaluator: import_zod.z.function().optional()
+});
+var SQLiteConfigSchema = import_zod.z.object({
+  filename: import_zod.z.string(),
+  memory: import_zod.z.boolean().optional()
+});
+var PostgresConfigSchema = import_zod.z.object({
+  host: import_zod.z.string(),
+  port: import_zod.z.number().optional(),
+  database: import_zod.z.string(),
+  user: import_zod.z.string(),
+  password: import_zod.z.string(),
+  ssl: import_zod.z.boolean().optional(),
+  max: import_zod.z.number().optional()
+});
+var RedisConfigSchema = import_zod.z.object({
+  host: import_zod.z.string(),
+  port: import_zod.z.number().optional(),
+  password: import_zod.z.string().optional(),
+  db: import_zod.z.number().optional(),
+  keyPrefix: import_zod.z.string().optional()
+});
+var MongoDBConfigSchema = import_zod.z.object({
+  url: import_zod.z.string(),
+  database: import_zod.z.string(),
+  useUnifiedTopology: import_zod.z.boolean().optional()
+});
+var LevelDBConfigSchema = import_zod.z.object({
+  path: import_zod.z.string()
+});
+var PersistenceConfigSchema = import_zod.z.object({
+  type: import_zod.z.enum(["memory", "postgres", "redis", "mongodb", "sqlite", "leveldb"]),
+  sqlite: SQLiteConfigSchema.optional(),
+  postgres: PostgresConfigSchema.optional(),
+  redis: RedisConfigSchema.optional(),
+  mongodb: MongoDBConfigSchema.optional(),
+  leveldb: LevelDBConfigSchema.optional(),
+  autoSaveIntervalMs: import_zod.z.number().int().positive().optional()
+});
+var BlockchainConfigSchema = import_zod.z.object({
+  rpcUrl: import_zod.z.string().url(),
+  privateKey: import_zod.z.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid private key format"),
+  entryFee: import_zod.z.number().nonnegative(),
+  requireMembership: import_zod.z.boolean().optional(),
+  enforceOnChainValidation: import_zod.z.boolean().optional(),
+  agentRegistryAddress: import_zod.z.string().optional(),
+  membershipContractAddress: import_zod.z.string().optional(),
+  worldTokenAddress: import_zod.z.string().optional(),
+  chainId: import_zod.z.number().int().optional()
+});
+var TokenConfigSchema = import_zod.z.object({
+  deploy: import_zod.z.boolean(),
+  name: import_zod.z.string().optional(),
+  symbol: import_zod.z.string().optional(),
+  initialSupply: import_zod.z.number().positive().optional(),
+  decimals: import_zod.z.number().int().min(0).max(18).optional()
+});
+var WorldConfigSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, "World name is required"),
+  description: import_zod.z.string().optional(),
+  type: import_zod.z.string().optional(),
+  server: import_zod.z.object({
+    port: import_zod.z.number().int().min(1).max(65535),
+    host: import_zod.z.string()
+  }),
+  a2a: import_zod.z.object({
+    baseUrl: import_zod.z.string().url(),
+    pushNotifications: import_zod.z.boolean().optional(),
+    streaming: import_zod.z.boolean().optional()
+  }).optional(),
+  admission: AdmissionRulesSchema,
+  simulation: import_zod.z.object({
+    tickIntervalMs: import_zod.z.number().int().positive().optional(),
+    maxTicks: import_zod.z.number().int().positive().optional(),
+    autoStart: import_zod.z.boolean().optional()
+  }).optional(),
+  persistence: PersistenceConfigSchema.optional(),
+  blockchain: BlockchainConfigSchema.optional(),
+  token: TokenConfigSchema.optional(),
+  rules: import_zod.z.array(import_zod.z.any()).optional(),
+  agentUrls: import_zod.z.array(import_zod.z.string().url()).optional()
+});
+function validateWorldConfig(config) {
+  try {
+    WorldConfigSchema.parse(config);
+  } catch (error) {
+    if (error instanceof import_zod.z.ZodError) {
+      const messages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(`Invalid world configuration: ${messages}`);
+    }
+    throw error;
+  }
+}
+function isValidWorldConfig(config) {
+  try {
+    WorldConfigSchema.parse(config);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/persistence/adapters/InMemoryAdapter.ts
+var InMemoryAdapter = class {
+  state = null;
+  events = [];
+  agents = /* @__PURE__ */ new Map();
+  async connect() {
+  }
+  async saveState(state) {
+    this.state = { ...state };
+  }
+  async loadState() {
+    return this.state ? { ...this.state } : null;
+  }
+  async saveEvent(event) {
+    this.events.push({ ...event });
+  }
+  async getEvents(filter) {
+    let filtered = [...this.events];
+    if (filter?.type) {
+      filtered = filtered.filter((e) => e.type === filter.type);
+    }
+    if (filter?.agentUrl) {
+      filtered = filtered.filter((e) => e.agentUrl === filter.agentUrl);
+    }
+    if (filter?.fromTimestamp) {
+      filtered = filtered.filter((e) => e.timestamp >= filter.fromTimestamp);
+    }
+    if (filter?.toTimestamp) {
+      filtered = filtered.filter((e) => e.timestamp <= filter.toTimestamp);
+    }
+    filtered.sort((a, b) => b.timestamp - a.timestamp);
+    if (filter?.limit) {
+      filtered = filtered.slice(0, filter.limit);
+    }
+    return filtered;
+  }
+  async saveAgent(profile) {
+    this.agents.set(profile.url, { ...profile });
+  }
+  async removeAgent(agentUrl) {
+    this.agents.delete(agentUrl);
+  }
+  async getAgents() {
+    return Array.from(this.agents.values()).map((a) => ({ ...a }));
+  }
+  async getAgent(agentUrl) {
+    const agent = this.agents.get(agentUrl);
+    return agent ? { ...agent } : null;
+  }
+  async disconnect() {
+  }
+  async healthCheck() {
+    return true;
+  }
+  async clear() {
+    this.state = null;
+    this.events = [];
+    this.agents.clear();
+  }
+};
+
+// src/persistence/PersistenceFactory.ts
+function createPersistence(config) {
+  switch (config.type) {
+    case "memory":
+      return new InMemoryAdapter();
+    case "sqlite":
+      return createSQLiteAdapter(config.sqlite || { filename: "./world.db" });
+    case "postgres":
+      if (!config.postgres) {
+        throw new Error("PostgreSQL configuration is required");
+      }
+      return createPostgresAdapter(config.postgres);
+    case "redis":
+      if (!config.redis) {
+        throw new Error("Redis configuration is required");
+      }
+      return createRedisAdapter(config.redis);
+    case "mongodb":
+      if (!config.mongodb) {
+        throw new Error("MongoDB configuration is required");
+      }
+      return createMongoAdapter(config.mongodb);
+    case "leveldb":
+      if (!config.leveldb) {
+        throw new Error("LevelDB configuration is required");
+      }
+      return createLevelDBAdapter(config.leveldb);
+    default:
+      throw new Error(`Unknown persistence type: ${config.type}`);
+  }
+}
+function createSQLiteAdapter(config) {
+  try {
+    const { SQLiteAdapter: SQLiteAdapter2 } = (init_SQLiteAdapter(), __toCommonJS(SQLiteAdapter_exports));
+    return new SQLiteAdapter2(config);
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        "SQLite adapter requires better-sqlite3. Install it with: npm install better-sqlite3"
+      );
+    }
+    throw error;
+  }
+}
+function createPostgresAdapter(config) {
+  try {
+    const { PostgresAdapter: PostgresAdapter2 } = (init_PostgresAdapter(), __toCommonJS(PostgresAdapter_exports));
+    return new PostgresAdapter2(config);
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        "PostgreSQL adapter requires pg. Install it with: npm install pg"
+      );
+    }
+    throw error;
+  }
+}
+function createRedisAdapter(config) {
+  try {
+    const { RedisAdapter: RedisAdapter2 } = (init_RedisAdapter(), __toCommonJS(RedisAdapter_exports));
+    return new RedisAdapter2(config);
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        "Redis adapter requires ioredis. Install it with: npm install ioredis"
+      );
+    }
+    throw error;
+  }
+}
+function createMongoAdapter(config) {
+  try {
+    const { MongoAdapter: MongoAdapter2 } = (init_MongoAdapter(), __toCommonJS(MongoAdapter_exports));
+    return new MongoAdapter2(config);
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        "MongoDB adapter requires mongodb. Install it with: npm install mongodb"
+      );
+    }
+    throw error;
+  }
+}
+function createLevelDBAdapter(config) {
+  try {
+    const { LevelDBAdapter: LevelDBAdapter2 } = (init_LevelDBAdapter(), __toCommonJS(LevelDBAdapter_exports));
+    return new LevelDBAdapter2(config);
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        "LevelDB adapter requires level. Install it with: npm install level"
+      );
+    }
+    throw error;
+  }
+}
+
+// src/index.ts
+init_logger();
+
+// src/engine/World.ts
+var import_uuid = require("uuid");
+init_CardFetcher();
+
+// src/discovery/AgentEvaluator.ts
+init_logger();
+var logger3 = createLogger("AgentEvaluator");
+var AgentEvaluator = class {
+  constructor(rules) {
+    this.rules = rules;
+  }
+  /**
+   * Evaluate whether an agent should be admitted.
+   * 
+   * @param card Agent's A2A card
+   * @param currentAgentCount Current number of agents in world
+   * @param walletAddress Optional wallet address for blockchain membership
+   * @returns Admission decision
+   */
+  async evaluate(card, currentAgentCount, walletAddress) {
+    logger3.debug(`Evaluating agent: ${card.name}`, {
+      currentAgents: currentAgentCount,
+      maxAgents: this.rules.maxAgents
+    });
+    if (this.rules.maxAgents && currentAgentCount >= this.rules.maxAgents) {
+      logger3.info(`Agent ${card.name} rejected: world is full`, {
+        current: currentAgentCount,
+        max: this.rules.maxAgents
+      });
+      return {
+        admitted: false,
+        reason: `World is full (${this.rules.maxAgents} agents maximum)`
+      };
+    }
+    if (this.rules.minProtocolVersion) {
+      if (!this.meetsProtocolVersion(card.protocolVersion, this.rules.minProtocolVersion)) {
+        logger3.info(`Agent ${card.name} rejected: protocol version too old`, {
+          agent: card.protocolVersion,
+          required: this.rules.minProtocolVersion
+        });
+        return {
+          admitted: false,
+          reason: `Protocol version ${card.protocolVersion} is below minimum ${this.rules.minProtocolVersion}`
+        };
+      }
+    }
+    if (this.rules.requiredSkills && this.rules.requiredSkills.length > 0) {
+      const agentSkillIds = card.skills.map((s) => s.id.toLowerCase());
+      const missingSkills = this.rules.requiredSkills.filter(
+        (required) => !agentSkillIds.includes(required.toLowerCase())
+      );
+      if (missingSkills.length > 0) {
+        logger3.info(`Agent ${card.name} rejected: missing required skills`, {
+          missing: missingSkills
+        });
+        return {
+          admitted: false,
+          reason: `Missing required skills: ${missingSkills.join(", ")}`
+        };
+      }
+    }
+    if (this.rules.requiredTags && this.rules.requiredTags.length > 0) {
+      const agentTags = card.skills.flatMap((s) => s.tags || []).map((t) => t.toLowerCase());
+      const hasRequiredTag = this.rules.requiredTags.some(
+        (required) => agentTags.includes(required.toLowerCase())
+      );
+      if (!hasRequiredTag) {
+        logger3.info(`Agent ${card.name} rejected: no matching tags`, {
+          required: this.rules.requiredTags
+        });
+        return {
+          admitted: false,
+          reason: `Must have at least one of these tags: ${this.rules.requiredTags.join(", ")}`
+        };
+      }
+    }
+    if (this.rules.customEvaluator) {
+      const profile = profileFromCard(card, walletAddress);
+      const customDecision = await this.rules.customEvaluator(profile);
+      if (!customDecision.admitted) {
+        logger3.info(`Agent ${card.name} rejected by custom evaluator`, {
+          reason: customDecision.reason
+        });
+        return customDecision;
+      }
+      if (customDecision.role || customDecision.metadata) {
+        logger3.debug(`Custom evaluator assigned role/metadata to ${card.name}`, {
+          role: customDecision.role
+        });
+      }
+      return customDecision;
+    }
+    logger3.info(`Agent ${card.name} admitted to world`);
+    return {
+      admitted: true,
+      reason: "All admission criteria met"
+    };
+  }
+  /**
+   * Check if agent's protocol version meets minimum requirement.
+   * Simple semver comparison (major.minor).
+   */
+  meetsProtocolVersion(agentVersion, minVersion) {
+    const parse = (v) => {
+      const parts = v.split(".");
+      return {
+        major: parseInt(parts[0] || "0", 10),
+        minor: parseInt(parts[1] || "0", 10)
+      };
+    };
+    const agent = parse(agentVersion);
+    const min = parse(minVersion);
+    if (agent.major > min.major) return true;
+    if (agent.major < min.major) return false;
+    return agent.minor >= min.minor;
+  }
+};
+
+// src/blockchain/BlockchainClient.ts
+var import_ethers = require("ethers");
+init_logger();
+var logger4 = createLogger("BlockchainClient");
+var AGENT_REGISTRY_ABI = [
+  "function registerAgent(string agentUrl, string name) external",
+  "function isAgentValid(address wallet) external view returns (bool)",
+  "function getAgent(address wallet) external view returns (tuple(address walletAddress, string agentUrl, string name, uint256 registeredAt, bool isActive))",
+  "function getWalletByUrl(string agentUrl) external view returns (address)",
+  "event AgentRegistered(address indexed wallet, string agentUrl, string name)"
+];
+var WORLD_MEMBERSHIP_ABI = [
+  "function mintMembership(address agent) external payable",
+  "function revokeMembership(address agent) external",
+  "function hasMembership(address agent) external view returns (bool)",
+  "function entryFee() external view returns (uint256)",
+  "function totalMembers() external view returns (uint256)",
+  "function withdrawFees() external",
+  "event MembershipMinted(address indexed agent, uint256 indexed tokenId, uint256 feePaid)"
+];
+var WORLD_TOKEN_ABI = [
+  "function mint(address to, uint256 amount) external",
+  "function burn(address from, uint256 amount) external",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function transfer(address to, uint256 amount) external returns (bool)"
+];
+var BlockchainClient = class {
+  constructor(config) {
+    this.config = config;
+    this.provider = new import_ethers.ethers.JsonRpcProvider(config.rpcUrl);
+    this.wallet = new import_ethers.ethers.Wallet(config.privateKey, this.provider);
+    logger4.info("Blockchain client initialized", {
+      network: config.rpcUrl,
+      wallet: this.wallet.address
+    });
+  }
+  provider;
+  wallet;
+  agentRegistry;
+  membershipContract;
+  worldToken;
+  /**
+   * Initialize contract connections
+   */
+  async init() {
+    if (this.config.agentRegistryAddress) {
+      this.agentRegistry = new import_ethers.ethers.Contract(
+        this.config.agentRegistryAddress,
+        AGENT_REGISTRY_ABI,
+        this.wallet
+      );
+      logger4.info("Connected to AgentRegistry", {
+        address: this.config.agentRegistryAddress
+      });
+    }
+    if (this.config.membershipContractAddress) {
+      this.membershipContract = new import_ethers.ethers.Contract(
+        this.config.membershipContractAddress,
+        WORLD_MEMBERSHIP_ABI,
+        this.wallet
+      );
+      logger4.info("Connected to WorldMembership", {
+        address: this.config.membershipContractAddress
+      });
+    }
+    if (this.config.worldTokenAddress) {
+      this.worldToken = new import_ethers.ethers.Contract(
+        this.config.worldTokenAddress,
+        WORLD_TOKEN_ABI,
+        this.wallet
+      );
+      logger4.info("Connected to WorldToken", {
+        address: this.config.worldTokenAddress
+      });
+    }
+    logger4.info("Blockchain client ready");
+  }
+  /**
+   * Validate agent on-chain
+   * @param walletAddress Agent's wallet address
+   * @returns True if agent is registered and valid
+   */
+  async validateAgent(walletAddress) {
+    if (!this.agentRegistry) {
+      logger4.warn("AgentRegistry not configured, skipping on-chain validation");
+      return true;
+    }
+    try {
+      const isValid = await this.agentRegistry.isAgentValid(walletAddress);
+      logger4.debug("Agent validation result", {
+        wallet: walletAddress,
+        isValid
+      });
+      return isValid;
+    } catch (error) {
+      logger4.error("Failed to validate agent on-chain", {
+        wallet: walletAddress,
+        error: error.message
+      });
+      return false;
+    }
+  }
+  /**
+   * Mint membership NFT for an agent
+   * @param agentWallet Agent's wallet address
+   * @returns Transaction hash
+   */
+  async mintMembership(agentWallet) {
+    if (!this.membershipContract) {
+      throw new Error("WorldMembership contract not configured");
+    }
+    try {
+      const entryFee = await this.membershipContract.entryFee();
+      logger4.info("Minting membership NFT", {
+        agent: agentWallet,
+        entryFee: import_ethers.ethers.formatEther(entryFee)
+      });
+      const tx = await this.membershipContract.mintMembership(agentWallet, {
+        value: entryFee
+      });
+      const receipt = await tx.wait();
+      logger4.info("Membership NFT minted", {
+        agent: agentWallet,
+        txHash: receipt.hash,
+        blockNumber: receipt.blockNumber
+      });
+      return receipt.hash;
+    } catch (error) {
+      logger4.error("Failed to mint membership NFT", {
+        agent: agentWallet,
+        error: error.message
+      });
+      throw error;
+    }
+  }
+  /**
+   * Check if agent has membership
+   * @param agentWallet Agent's wallet address
+   * @returns True if agent has membership
+   */
+  async hasMembership(agentWallet) {
+    if (!this.membershipContract) {
+      logger4.warn("WorldMembership not configured, skipping membership check");
+      return true;
+    }
+    try {
+      const hasMembership = await this.membershipContract.hasMembership(agentWallet);
+      return hasMembership;
+    } catch (error) {
+      logger4.error("Failed to check membership", {
+        agent: agentWallet,
+        error: error.message
+      });
+      return false;
+    }
+  }
+  /**
+   * Revoke membership NFT
+   * @param agentWallet Agent's wallet address
+   * @returns Transaction hash
+   */
+  async revokeMembership(agentWallet) {
+    if (!this.membershipContract) {
+      throw new Error("WorldMembership contract not configured");
+    }
+    try {
+      logger4.info("Revoking membership", { agent: agentWallet });
+      const tx = await this.membershipContract.revokeMembership(agentWallet);
+      const receipt = await tx.wait();
+      logger4.info("Membership revoked", {
+        agent: agentWallet,
+        txHash: receipt.hash
+      });
+      return receipt.hash;
+    } catch (error) {
+      logger4.error("Failed to revoke membership", {
+        agent: agentWallet,
+        error: error.message
+      });
+      throw error;
+    }
+  }
+  /**
+   * Get total number of members
+   */
+  async getTotalMembers() {
+    if (!this.membershipContract) {
+      return 0;
+    }
+    try {
+      const total = await this.membershipContract.totalMembers();
+      return Number(total);
+    } catch (error) {
+      logger4.error("Failed to get total members", { error: error.message });
+      return 0;
+    }
+  }
+  /**
+   * Withdraw collected entry fees (world owner only)
+   */
+  async withdrawFees() {
+    if (!this.membershipContract) {
+      throw new Error("WorldMembership contract not configured");
+    }
+    try {
+      logger4.info("Withdrawing entry fees");
+      const tx = await this.membershipContract.withdrawFees();
+      const receipt = await tx.wait();
+      logger4.info("Fees withdrawn", {
+        txHash: receipt.hash,
+        blockNumber: receipt.blockNumber
+      });
+      return receipt.hash;
+    } catch (error) {
+      logger4.error("Failed to withdraw fees", { error: error.message });
+      throw error;
+    }
+  }
+  /**
+   * Get world owner's wallet address
+   */
+  getWalletAddress() {
+    return this.wallet.address;
+  }
+  /**
+   * Get entry fee in MON
+   */
+  async getEntryFee() {
+    if (!this.membershipContract) {
+      return "0";
+    }
+    try {
+      const fee = await this.membershipContract.entryFee();
+      return import_ethers.ethers.formatEther(fee);
+    } catch (error) {
+      logger4.error("Failed to get entry fee", { error: error.message });
+      return "0";
+    }
+  }
+};
+
+// src/engine/World.ts
+init_logger();
+var logger5 = createLogger("World");
+var World = class {
+  constructor(config) {
+    this.config = config;
+    validateWorldConfig(config);
+    this.state = {
+      phase: "idle",
+      tick: 0,
+      round: 0,
+      timestamp: Date.now(),
+      metadata: {}
+    };
+    this.agents = /* @__PURE__ */ new Map();
+    this.cardFetcher = new CardFetcher();
+    this.evaluator = new AgentEvaluator(config.admission);
+    logger5.info(`World "${config.name}" created`, {
+      type: config.type || "generic",
+      maxAgents: config.admission.maxAgents
+    });
+  }
+  state;
+  agents;
+  persistence = null;
+  blockchainClient = null;
+  cardFetcher;
+  evaluator;
+  tickInterval = null;
+  autoSaveInterval = null;
+  /**
+   * Initialize the world (connect persistence, restore state, discover agents)
+   */
+  async init() {
+    logger5.info("Initializing world...");
+    this.setState("initializing");
+    try {
+      if (this.config.persistence) {
+        logger5.info("Connecting to persistence backend:", this.config.persistence.type);
+        this.persistence = createPersistence(this.config.persistence);
+        await this.persistence.connect();
+        const savedState = await this.persistence.loadState();
+        if (savedState) {
+          this.state = savedState;
+          logger5.info("Restored world state from persistence", {
+            phase: savedState.phase,
+            tick: savedState.tick
+          });
+          const savedAgents = await this.persistence.getAgents();
+          for (const agent of savedAgents) {
+            this.agents.set(agent.url, agent);
+          }
+          logger5.info(`Restored ${savedAgents.length} agents from persistence`);
+        }
+      }
+      if (this.config.blockchain) {
+        logger5.info("Initializing blockchain client...");
+        this.blockchainClient = new BlockchainClient(this.config.blockchain);
+        await this.blockchainClient.init();
+      }
+      if (this.config.agentUrls && this.config.agentUrls.length > 0) {
+        logger5.info(`Discovering ${this.config.agentUrls.length} pre-configured agents...`);
+        const results = await this.cardFetcher.fetchCards(this.config.agentUrls);
+        for (let i = 0; i < results.length; i++) {
+          const result = results[i];
+          if (result.success && result.card) {
+            try {
+              await this.admitAgent(result.card);
+            } catch (error) {
+              logger5.warn(`Failed to admit pre-configured agent:`, error.message);
+            }
+          }
+        }
+      }
+      if (this.persistence) {
+        this.startAutoSave();
+      }
+      this.setState("ready");
+      logger5.info("World initialized successfully", {
+        agents: this.agents.size,
+        persistence: this.config.persistence?.type || "none"
+      });
+    } catch (error) {
+      logger5.error("Failed to initialize world:", error);
+      this.setState("failed");
+      throw error;
+    }
+  }
+  /**
+   * Start the world simulation
+   */
+  async start() {
+    if (this.state.phase === "running") {
+      logger5.warn("World is already running");
+      return;
+    }
+    logger5.info("Starting world simulation...");
+    this.setState("running");
+    await this.logEvent({
+      id: (0, import_uuid.v4)(),
+      type: "world_started",
+      timestamp: Date.now()
+    });
+    if (this.config.simulation?.tickIntervalMs) {
+      this.startTicking();
+    }
+  }
+  /**
+   * Stop the world simulation
+   */
+  async stop() {
+    logger5.info("Stopping world...");
+    this.setState("stopped");
+    if (this.tickInterval) {
+      clearInterval(this.tickInterval);
+      this.tickInterval = null;
+    }
+    if (this.autoSaveInterval) {
+      clearInterval(this.autoSaveInterval);
+      this.autoSaveInterval = null;
+    }
+    if (this.persistence) {
+      await this.persistence.saveState(this.state);
+    }
+    await this.logEvent({
+      id: (0, import_uuid.v4)(),
+      type: "world_stopped",
+      timestamp: Date.now()
+    });
+    logger5.info("World stopped");
+  }
+  /**
+   * Admit an agent to the world
+   */
+  async admitAgent(card, walletAddress) {
+    const decision = await this.evaluator.evaluate(card, this.agents.size, walletAddress);
+    if (!decision.admitted) {
+      throw new Error(`Agent admission denied: ${decision.reason}`);
+    }
+    if (this.blockchainClient && this.config.blockchain?.enforceOnChainValidation && walletAddress) {
+      const isValid = await this.blockchainClient.validateAgent(walletAddress);
+      if (!isValid) {
+        throw new Error("Agent not registered in on-chain AgentRegistry");
+      }
+      logger5.info(`Agent validated on-chain: ${card.name}`);
+    }
+    if (this.blockchainClient && this.config.blockchain?.requireMembership && walletAddress) {
+      const hasMembership = await this.blockchainClient.hasMembership(walletAddress);
+      if (!hasMembership) {
+        logger5.info(`Minting membership NFT for agent: ${card.name}`);
+        await this.blockchainClient.mintMembership(walletAddress);
+      } else {
+        logger5.info(`Agent already has membership: ${card.name}`);
+      }
+    }
+    const profile = {
+      url: card.url,
+      name: card.name,
+      protocolVersion: card.protocolVersion,
+      skills: card.skills,
+      capabilities: {
+        streaming: card.capabilities.streaming ?? false,
+        pushNotifications: card.capabilities.pushNotifications ?? false,
+        stateTransitionHistory: card.capabilities.stateTransitionHistory
+      },
+      joinedAt: Date.now(),
+      role: decision.role,
+      metadata: decision.metadata,
+      walletAddress
+    };
+    this.agents.set(profile.url, profile);
+    if (this.persistence) {
+      await this.persistence.saveAgent(profile);
+    }
+    await this.logEvent({
+      id: (0, import_uuid.v4)(),
+      type: "agent_joined",
+      timestamp: Date.now(),
+      agentUrl: profile.url,
+      data: { name: profile.name, role: profile.role }
+    });
+    logger5.info(`Agent admitted: ${profile.name}`, {
+      role: profile.role,
+      totalAgents: this.agents.size
+    });
+  }
+  /**
+   * Remove an agent from the world
+   */
+  async removeAgent(agentUrl) {
+    const agent = this.agents.get(agentUrl);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentUrl}`);
+    }
+    this.agents.delete(agentUrl);
+    if (this.persistence) {
+      await this.persistence.removeAgent(agentUrl);
+    }
+    await this.logEvent({
+      id: (0, import_uuid.v4)(),
+      type: "agent_left",
+      timestamp: Date.now(),
+      agentUrl,
+      data: { name: agent.name }
+    });
+    logger5.info(`Agent removed: ${agent.name}`, {
+      totalAgents: this.agents.size
+    });
+  }
+  /**
+   * Get all agents in the world
+   */
+  getAgents() {
+    return Array.from(this.agents.values());
+  }
+  /**
+   * Get current world state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Log an event
+   */
+  async logEvent(event) {
+    if (this.persistence) {
+      await this.persistence.saveEvent(event);
+    }
+  }
+  /**
+   * Set world phase
+   */
+  setState(phase) {
+    this.state.phase = phase;
+    this.state.timestamp = Date.now();
+  }
+  /**
+   * Start auto-save interval
+   */
+  startAutoSave() {
+    const interval = this.config.persistence?.autoSaveIntervalMs || 1e4;
+    this.autoSaveInterval = setInterval(async () => {
+      if (this.persistence) {
+        await this.persistence.saveState(this.state);
+        logger5.debug("Auto-saved world state");
+      }
+    }, interval);
+    logger5.info(`Auto-save enabled (interval: ${interval}ms)`);
+  }
+  /**
+   * Start simulation ticking
+   */
+  startTicking() {
+    const interval = this.config.simulation.tickIntervalMs;
+    this.tickInterval = setInterval(async () => {
+      this.state.tick++;
+      await this.logEvent({
+        id: (0, import_uuid.v4)(),
+        type: "tick",
+        timestamp: Date.now(),
+        data: { tick: this.state.tick }
+      });
+      logger5.debug(`Tick ${this.state.tick}`);
+      if (this.config.simulation?.maxTicks && this.state.tick >= this.config.simulation.maxTicks) {
+        logger5.info("Max ticks reached, stopping world");
+        await this.stop();
+      }
+    }, interval);
+    logger5.info(`Simulation ticking enabled (interval: ${interval}ms)`);
+  }
+};
+
+// src/index.ts
+init_CardFetcher();
+
+// src/server/app.ts
+var import_express = __toESM(require("express"), 1);
+init_logger();
+var logger6 = createLogger("WorldServer");
+function createWorldApp(world) {
+  const app = (0, import_express.default)();
+  app.use(import_express.default.json());
+  app.use(import_express.default.urlencoded({ extended: true }));
+  app.use((req, res, next) => {
+    logger6.debug(`${req.method} ${req.path}`, {
+      query: req.query,
+      ip: req.ip
+    });
+    next();
+  });
+  app.get("/", (req, res) => {
+    res.json({
+      name: world.config.name,
+      description: world.config.description,
+      type: world.config.type || "generic",
+      state: world.getState(),
+      agentCount: world.getAgents().length,
+      maxAgents: world.config.admission.maxAgents || null,
+      admission: {
+        requiredSkills: world.config.admission.requiredSkills || [],
+        requiredTags: world.config.admission.requiredTags || [],
+        minProtocolVersion: world.config.admission.minProtocolVersion || null
+      }
+    });
+  });
+  app.post("/world/join", async (req, res) => {
+    try {
+      const { agentUrl, walletAddress } = req.body;
+      if (!agentUrl) {
+        return res.status(400).json({
+          success: false,
+          error: "agentUrl is required"
+        });
+      }
+      logger6.info(`Agent join request from: ${agentUrl}`, {
+        wallet: walletAddress || "none"
+      });
+      const cardFetcher = new (await Promise.resolve().then(() => (init_CardFetcher(), CardFetcher_exports))).CardFetcher();
+      const result = await cardFetcher.fetchCard(agentUrl);
+      if (!result.success || !result.card) {
+        return res.status(400).json({
+          success: false,
+          error: `Failed to fetch agent card: ${result.error}`
+        });
+      }
+      await world.admitAgent(result.card, walletAddress);
+      res.json({
+        success: true,
+        message: "Agent admitted to world",
+        world: {
+          name: world.config.name,
+          agentCount: world.getAgents().length
+        }
+      });
+    } catch (error) {
+      logger6.error("Failed to process join request:", error);
+      res.status(400).json({
+        success: false,
+        error: error.message || "Failed to join world"
+      });
+    }
+  });
+  app.get("/world/agents", (req, res) => {
+    const agents = world.getAgents().map((agent) => ({
+      url: agent.url,
+      name: agent.name,
+      protocolVersion: agent.protocolVersion,
+      skills: agent.skills.map((s) => s.id),
+      joinedAt: agent.joinedAt,
+      role: agent.role
+    }));
+    res.json({
+      agents,
+      count: agents.length
+    });
+  });
+  app.get("/world/state", (req, res) => {
+    res.json(world.getState());
+  });
+  app.post("/world/start", async (req, res) => {
+    try {
+      await world.start();
+      res.json({
+        success: true,
+        message: "World simulation started",
+        state: world.getState()
+      });
+    } catch (error) {
+      res.status(400).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+  app.post("/world/stop", async (req, res) => {
+    try {
+      await world.stop();
+      res.json({
+        success: true,
+        message: "World simulation stopped",
+        state: world.getState()
+      });
+    } catch (error) {
+      res.status(400).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+  app.delete("/world/agents/:agentUrl", async (req, res) => {
+    try {
+      const agentUrlParam = req.params.agentUrl;
+      const agentUrl = typeof agentUrlParam === "string" ? decodeURIComponent(agentUrlParam) : decodeURIComponent(agentUrlParam[0]);
+      await world.removeAgent(agentUrl);
+      res.json({
+        success: true,
+        message: "Agent removed from world"
+      });
+    } catch (error) {
+      res.status(400).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+  app.use((req, res) => {
+    res.status(404).json({
+      error: "Not found",
+      path: req.path
+    });
+  });
+  app.use((err, req, res, next) => {
+    logger6.error("Server error:", err);
+    res.status(500).json({
+      error: "Internal server error",
+      message: err.message
+    });
+  });
+  return app;
+}
+async function startWorldServer(world) {
+  const app = createWorldApp(world);
+  const server = app.listen(world.config.server.port, world.config.server.host, () => {
+    const { host, port } = world.config.server;
+    logger6.info(`World "${world.config.name}" server started`);
+    logger6.info(`  http://${host}:${port}`);
+    logger6.info("");
+    logger6.info("Endpoints:");
+    logger6.info(`  GET    /                    - World info`);
+    logger6.info(`  POST   /world/join          - Agent join request`);
+    logger6.info(`  GET    /world/agents        - List agents`);
+    logger6.info(`  GET    /world/state         - World state`);
+    logger6.info(`  POST   /world/start         - Start simulation`);
+    logger6.info(`  POST   /world/stop          - Stop simulation`);
+    logger6.info(`  DELETE /world/agents/:url   - Remove agent`);
+  });
+  process.on("SIGTERM", async () => {
+    logger6.info("SIGTERM received, shutting down gracefully...");
+    server.close(async () => {
+      await world.stop();
+      process.exit(0);
+    });
+  });
+  process.on("SIGINT", async () => {
+    logger6.info("SIGINT received, shutting down gracefully...");
+    server.close(async () => {
+      await world.stop();
+      process.exit(0);
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdmissionRulesSchema,
+  AgentEvaluator,
+  BlockchainClient,
+  BlockchainConfigSchema,
+  CardFetcher,
+  InMemoryAdapter,
+  PersistenceConfigSchema,
+  TokenConfigSchema,
+  World,
+  WorldConfigSchema,
+  createLogger,
+  createPersistence,
+  createWorldApp,
+  isValidWorldConfig,
+  logger,
+  normalizeAgentUrl,
+  profileFromCard,
+  startWorldServer,
+  validateWorldConfig
+});
+//# sourceMappingURL=index.cjs.map