@moltium/world-core 0.1.8 → 0.1.9

package/dist/index.js

@@ -1,1041 +1,9 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/persistence/adapters/SQLiteAdapter.ts
-var SQLiteAdapter_exports = {};
-__export(SQLiteAdapter_exports, {
-  SQLiteAdapter: () => SQLiteAdapter
-});
-import Database from "better-sqlite3";
-var SQLiteAdapter;
-var init_SQLiteAdapter = __esm({
-  "src/persistence/adapters/SQLiteAdapter.ts"() {
-    "use strict";
-    SQLiteAdapter = class {
-      constructor(config) {
-        this.config = config;
-      }
-      db;
-      async connect() {
-        this.db = new Database(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
-});
-import pkg from "pg";
-var Pool, PostgresAdapter;
-var init_PostgresAdapter = __esm({
-  "src/persistence/adapters/PostgresAdapter.ts"() {
-    "use strict";
-    ({ Pool } = pkg);
-    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
-});
-import { Redis } from "ioredis";
-var RedisAdapter;
-var init_RedisAdapter = __esm({
-  "src/persistence/adapters/RedisAdapter.ts"() {
-    "use strict";
-    RedisAdapter = class {
-      constructor(config) {
-        this.config = config;
-        this.keyPrefix = config.keyPrefix || "world:";
-        this.client = new 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
-});
-import { MongoClient } from "mongodb";
-var MongoAdapter;
-var init_MongoAdapter = __esm({
-  "src/persistence/adapters/MongoAdapter.ts"() {
-    "use strict";
-    MongoAdapter = class {
-      constructor(config) {
-        this.config = config;
-        this.client = new 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
-});
-import { Level } from "level";
-var LevelDBAdapter;
-var init_LevelDBAdapter = __esm({
-  "src/persistence/adapters/LevelDBAdapter.ts"() {
-    "use strict";
-    LevelDBAdapter = class {
-      constructor(config) {
-        this.config = config;
-      }
-      db;
-      connected = false;
-      async connect() {
-        try {
-          this.db = new 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
-import winston from "winston";
-function createLogger(moduleName) {
-  return logger.child({ module: moduleName });
-}
-var logLevel, logger;
-var init_logger = __esm({
-  "src/logger.ts"() {
-    "use strict";
-    logLevel = process.env.LOG_LEVEL || "info";
-    logger = winston.createLogger({
-      level: logLevel,
-      format: winston.format.combine(
-        winston.format.timestamp(),
-        winston.format.colorize(),
-        winston.format.printf(({ level, message, timestamp, ...meta }) => {
-          const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
-          return `${timestamp} [${level}] ${message}${metaStr}`;
-        })
-      ),
-      transports: [new winston.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;
-      }
-    };
-  }
-});
+import {
+  CardFetcher,
+  createLogger,
+  logger,
+  normalizeAgentUrl
+} from "./chunk-JW3PZRCW.js";
 
 // src/config/types.ts
 function profileFromCard(card, walletAddress) {
@@ -1225,7 +193,7 @@ var InMemoryAdapter = class {
 };
 
 // src/persistence/PersistenceFactory.ts
-function createPersistence(config) {
+async function createPersistence(config) {
   switch (config.type) {
     case "memory":
       return new InMemoryAdapter();
@@ -1255,12 +223,120 @@ function createPersistence(config) {
       throw new Error(`Unknown persistence type: ${config.type}`);
   }
 }
-function createSQLiteAdapter(config) {
+async function createSQLiteAdapter(config) {
   try {
-    const { SQLiteAdapter: SQLiteAdapter2 } = (init_SQLiteAdapter(), __toCommonJS(SQLiteAdapter_exports));
-    return new SQLiteAdapter2(config);
+    const Database = (await import("better-sqlite3")).default;
+    return new class {
+      db;
+      async connect() {
+        this.db = new Database(config.filename);
+        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) {
+        this.db.prepare("DELETE FROM agents WHERE url = ?").run(agentUrl);
+      }
+      async getAgents() {
+        const rows = this.db.prepare("SELECT * FROM agents ORDER BY joined_at ASC").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 row = this.db.prepare("SELECT * FROM agents WHERE url = ?").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 {
+          this.db.prepare("SELECT 1").get();
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async clear() {
+        this.db.exec("DELETE FROM world_state; DELETE FROM events; DELETE FROM agents;");
+      }
+    }();
   } catch (error) {
-    if (error.code === "MODULE_NOT_FOUND") {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
       throw new Error(
         "SQLite adapter requires better-sqlite3. Install it with: npm install better-sqlite3"
       );
@@ -1268,12 +344,14 @@ function createSQLiteAdapter(config) {
     throw error;
   }
 }
-function createPostgresAdapter(config) {
+async function createPostgresAdapter(config) {
   try {
-    const { PostgresAdapter: PostgresAdapter2 } = (init_PostgresAdapter(), __toCommonJS(PostgresAdapter_exports));
-    return new PostgresAdapter2(config);
+    const pg = await import("pg");
+    const Pool = pg.default?.Pool || pg.Pool;
+    const { PostgresAdapter } = await import("./PostgresAdapter-PLXDLHVF.js");
+    return new PostgresAdapter(config);
   } catch (error) {
-    if (error.code === "MODULE_NOT_FOUND") {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
       throw new Error(
         "PostgreSQL adapter requires pg. Install it with: npm install pg"
       );
@@ -1281,12 +359,13 @@ function createPostgresAdapter(config) {
     throw error;
   }
 }
-function createRedisAdapter(config) {
+async function createRedisAdapter(config) {
   try {
-    const { RedisAdapter: RedisAdapter2 } = (init_RedisAdapter(), __toCommonJS(RedisAdapter_exports));
-    return new RedisAdapter2(config);
+    await import("ioredis");
+    const { RedisAdapter } = await import("./RedisAdapter-OL4FVEGL.js");
+    return new RedisAdapter(config);
   } catch (error) {
-    if (error.code === "MODULE_NOT_FOUND") {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
       throw new Error(
         "Redis adapter requires ioredis. Install it with: npm install ioredis"
       );
@@ -1294,12 +373,13 @@ function createRedisAdapter(config) {
     throw error;
   }
 }
-function createMongoAdapter(config) {
+async function createMongoAdapter(config) {
   try {
-    const { MongoAdapter: MongoAdapter2 } = (init_MongoAdapter(), __toCommonJS(MongoAdapter_exports));
-    return new MongoAdapter2(config);
+    await import("mongodb");
+    const { MongoAdapter } = await import("./MongoAdapter-TCY6JOZH.js");
+    return new MongoAdapter(config);
   } catch (error) {
-    if (error.code === "MODULE_NOT_FOUND") {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
       throw new Error(
         "MongoDB adapter requires mongodb. Install it with: npm install mongodb"
       );
@@ -1307,12 +387,13 @@ function createMongoAdapter(config) {
     throw error;
   }
 }
-function createLevelDBAdapter(config) {
+async function createLevelDBAdapter(config) {
   try {
-    const { LevelDBAdapter: LevelDBAdapter2 } = (init_LevelDBAdapter(), __toCommonJS(LevelDBAdapter_exports));
-    return new LevelDBAdapter2(config);
+    await import("level");
+    const { LevelDBAdapter } = await import("./LevelDBAdapter-ZV2ZTDOV.js");
+    return new LevelDBAdapter(config);
   } catch (error) {
-    if (error.code === "MODULE_NOT_FOUND") {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
       throw new Error(
         "LevelDB adapter requires level. Install it with: npm install level"
       );
@@ -1321,16 +402,11 @@ function createLevelDBAdapter(config) {
   }
 }
 
-// src/index.ts
-init_logger();
-
 // src/engine/World.ts
 import { v4 as uuidv4 } from "uuid";
-init_CardFetcher();
 
 // src/discovery/AgentEvaluator.ts
-init_logger();
-var logger3 = createLogger("AgentEvaluator");
+var logger2 = createLogger("AgentEvaluator");
 var AgentEvaluator = class {
   constructor(rules) {
     this.rules = rules;
@@ -1344,12 +420,12 @@ var AgentEvaluator = class {
    * @returns Admission decision
    */
   async evaluate(card, currentAgentCount, walletAddress) {
-    logger3.debug(`Evaluating agent: ${card.name}`, {
+    logger2.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`, {
+      logger2.info(`Agent ${card.name} rejected: world is full`, {
         current: currentAgentCount,
         max: this.rules.maxAgents
       });
@@ -1360,7 +436,7 @@ var AgentEvaluator = class {
     }
     if (this.rules.minProtocolVersion) {
       if (!this.meetsProtocolVersion(card.protocolVersion, this.rules.minProtocolVersion)) {
-        logger3.info(`Agent ${card.name} rejected: protocol version too old`, {
+        logger2.info(`Agent ${card.name} rejected: protocol version too old`, {
           agent: card.protocolVersion,
           required: this.rules.minProtocolVersion
         });
@@ -1376,7 +452,7 @@ var AgentEvaluator = class {
         (required) => !agentSkillIds.includes(required.toLowerCase())
       );
       if (missingSkills.length > 0) {
-        logger3.info(`Agent ${card.name} rejected: missing required skills`, {
+        logger2.info(`Agent ${card.name} rejected: missing required skills`, {
           missing: missingSkills
         });
         return {
@@ -1391,7 +467,7 @@ var AgentEvaluator = class {
         (required) => agentTags.includes(required.toLowerCase())
       );
       if (!hasRequiredTag) {
-        logger3.info(`Agent ${card.name} rejected: no matching tags`, {
+        logger2.info(`Agent ${card.name} rejected: no matching tags`, {
           required: this.rules.requiredTags
         });
         return {
@@ -1404,19 +480,19 @@ var AgentEvaluator = class {
       const profile = profileFromCard(card, walletAddress);
       const customDecision = await this.rules.customEvaluator(profile);
       if (!customDecision.admitted) {
-        logger3.info(`Agent ${card.name} rejected by custom evaluator`, {
+        logger2.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}`, {
+        logger2.debug(`Custom evaluator assigned role/metadata to ${card.name}`, {
           role: customDecision.role
         });
       }
       return customDecision;
     }
-    logger3.info(`Agent ${card.name} admitted to world`);
+    logger2.info(`Agent ${card.name} admitted to world`);
     return {
       admitted: true,
       reason: "All admission criteria met"
@@ -1443,9 +519,8 @@ var AgentEvaluator = class {
 };
 
 // src/blockchain/BlockchainClient.ts
-init_logger();
 import { ethers } from "ethers";
-var logger4 = createLogger("BlockchainClient");
+var logger3 = createLogger("BlockchainClient");
 var AGENT_REGISTRY_ABI = [
   "function registerAgent(string agentUrl, string name) external",
   "function isAgentValid(address wallet) external view returns (bool)",
@@ -1473,7 +548,7 @@ var BlockchainClient = class {
     this.config = config;
     this.provider = new ethers.JsonRpcProvider(config.rpcUrl);
     this.wallet = new ethers.Wallet(config.privateKey, this.provider);
-    logger4.info("Blockchain client initialized", {
+    logger3.info("Blockchain client initialized", {
       network: config.rpcUrl,
       wallet: this.wallet.address
     });
@@ -1493,7 +568,7 @@ var BlockchainClient = class {
         AGENT_REGISTRY_ABI,
         this.wallet
       );
-      logger4.info("Connected to AgentRegistry", {
+      logger3.info("Connected to AgentRegistry", {
         address: this.config.agentRegistryAddress
       });
     }
@@ -1503,7 +578,7 @@ var BlockchainClient = class {
         WORLD_MEMBERSHIP_ABI,
         this.wallet
       );
-      logger4.info("Connected to WorldMembership", {
+      logger3.info("Connected to WorldMembership", {
         address: this.config.membershipContractAddress
       });
     }
@@ -1513,11 +588,11 @@ var BlockchainClient = class {
         WORLD_TOKEN_ABI,
         this.wallet
       );
-      logger4.info("Connected to WorldToken", {
+      logger3.info("Connected to WorldToken", {
         address: this.config.worldTokenAddress
       });
     }
-    logger4.info("Blockchain client ready");
+    logger3.info("Blockchain client ready");
   }
   /**
    * Validate agent on-chain
@@ -1526,18 +601,18 @@ var BlockchainClient = class {
    */
   async validateAgent(walletAddress) {
     if (!this.agentRegistry) {
-      logger4.warn("AgentRegistry not configured, skipping on-chain validation");
+      logger3.warn("AgentRegistry not configured, skipping on-chain validation");
       return true;
     }
     try {
       const isValid = await this.agentRegistry.isAgentValid(walletAddress);
-      logger4.debug("Agent validation result", {
+      logger3.debug("Agent validation result", {
         wallet: walletAddress,
         isValid
       });
       return isValid;
     } catch (error) {
-      logger4.error("Failed to validate agent on-chain", {
+      logger3.error("Failed to validate agent on-chain", {
         wallet: walletAddress,
         error: error.message
       });
@@ -1555,7 +630,7 @@ var BlockchainClient = class {
     }
     try {
       const entryFee = await this.membershipContract.entryFee();
-      logger4.info("Minting membership NFT", {
+      logger3.info("Minting membership NFT", {
         agent: agentWallet,
         entryFee: ethers.formatEther(entryFee)
       });
@@ -1563,14 +638,14 @@ var BlockchainClient = class {
         value: entryFee
       });
       const receipt = await tx.wait();
-      logger4.info("Membership NFT minted", {
+      logger3.info("Membership NFT minted", {
         agent: agentWallet,
         txHash: receipt.hash,
         blockNumber: receipt.blockNumber
       });
       return receipt.hash;
     } catch (error) {
-      logger4.error("Failed to mint membership NFT", {
+      logger3.error("Failed to mint membership NFT", {
         agent: agentWallet,
         error: error.message
       });
@@ -1584,14 +659,14 @@ var BlockchainClient = class {
    */
   async hasMembership(agentWallet) {
     if (!this.membershipContract) {
-      logger4.warn("WorldMembership not configured, skipping membership check");
+      logger3.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", {
+      logger3.error("Failed to check membership", {
         agent: agentWallet,
         error: error.message
       });
@@ -1608,16 +683,16 @@ var BlockchainClient = class {
       throw new Error("WorldMembership contract not configured");
     }
     try {
-      logger4.info("Revoking membership", { agent: agentWallet });
+      logger3.info("Revoking membership", { agent: agentWallet });
       const tx = await this.membershipContract.revokeMembership(agentWallet);
       const receipt = await tx.wait();
-      logger4.info("Membership revoked", {
+      logger3.info("Membership revoked", {
         agent: agentWallet,
         txHash: receipt.hash
       });
       return receipt.hash;
     } catch (error) {
-      logger4.error("Failed to revoke membership", {
+      logger3.error("Failed to revoke membership", {
         agent: agentWallet,
         error: error.message
       });
@@ -1635,7 +710,7 @@ var BlockchainClient = class {
       const total = await this.membershipContract.totalMembers();
       return Number(total);
     } catch (error) {
-      logger4.error("Failed to get total members", { error: error.message });
+      logger3.error("Failed to get total members", { error: error.message });
       return 0;
     }
   }
@@ -1647,16 +722,16 @@ var BlockchainClient = class {
       throw new Error("WorldMembership contract not configured");
     }
     try {
-      logger4.info("Withdrawing entry fees");
+      logger3.info("Withdrawing entry fees");
       const tx = await this.membershipContract.withdrawFees();
       const receipt = await tx.wait();
-      logger4.info("Fees withdrawn", {
+      logger3.info("Fees withdrawn", {
         txHash: receipt.hash,
         blockNumber: receipt.blockNumber
       });
       return receipt.hash;
     } catch (error) {
-      logger4.error("Failed to withdraw fees", { error: error.message });
+      logger3.error("Failed to withdraw fees", { error: error.message });
       throw error;
     }
   }
@@ -1677,15 +752,14 @@ var BlockchainClient = class {
       const fee = await this.membershipContract.entryFee();
       return ethers.formatEther(fee);
     } catch (error) {
-      logger4.error("Failed to get entry fee", { error: error.message });
+      logger3.error("Failed to get entry fee", { error: error.message });
       return "0";
     }
   }
 };
 
 // src/engine/World.ts
-init_logger();
-var logger5 = createLogger("World");
+var logger4 = createLogger("World");
 var World = class {
   constructor(config) {
     this.config = config;
@@ -1700,7 +774,7 @@ var World = class {
     this.agents = /* @__PURE__ */ new Map();
     this.cardFetcher = new CardFetcher();
     this.evaluator = new AgentEvaluator(config.admission);
-    logger5.info(`World "${config.name}" created`, {
+    logger4.info(`World "${config.name}" created`, {
       type: config.type || "generic",
       maxAgents: config.admission.maxAgents
     });
@@ -1717,17 +791,17 @@ var World = class {
    * Initialize the world (connect persistence, restore state, discover agents)
    */
   async init() {
-    logger5.info("Initializing world...");
+    logger4.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);
+        logger4.info("Connecting to persistence backend:", this.config.persistence.type);
+        this.persistence = await 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", {
+          logger4.info("Restored world state from persistence", {
             phase: savedState.phase,
             tick: savedState.tick
           });
@@ -1735,16 +809,16 @@ var World = class {
           for (const agent of savedAgents) {
             this.agents.set(agent.url, agent);
           }
-          logger5.info(`Restored ${savedAgents.length} agents from persistence`);
+          logger4.info(`Restored ${savedAgents.length} agents from persistence`);
         }
       }
       if (this.config.blockchain) {
-        logger5.info("Initializing blockchain client...");
+        logger4.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...`);
+        logger4.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];
@@ -1752,7 +826,7 @@ var World = class {
             try {
               await this.admitAgent(result.card);
             } catch (error) {
-              logger5.warn(`Failed to admit pre-configured agent:`, error.message);
+              logger4.warn(`Failed to admit pre-configured agent:`, error.message);
             }
           }
         }
@@ -1761,12 +835,12 @@ var World = class {
         this.startAutoSave();
       }
       this.setState("ready");
-      logger5.info("World initialized successfully", {
+      logger4.info("World initialized successfully", {
         agents: this.agents.size,
         persistence: this.config.persistence?.type || "none"
       });
     } catch (error) {
-      logger5.error("Failed to initialize world:", error);
+      logger4.error("Failed to initialize world:", error);
       this.setState("failed");
       throw error;
     }
@@ -1776,10 +850,10 @@ var World = class {
    */
   async start() {
     if (this.state.phase === "running") {
-      logger5.warn("World is already running");
+      logger4.warn("World is already running");
       return;
     }
-    logger5.info("Starting world simulation...");
+    logger4.info("Starting world simulation...");
     this.setState("running");
     await this.logEvent({
       id: uuidv4(),
@@ -1794,7 +868,7 @@ var World = class {
    * Stop the world simulation
    */
   async stop() {
-    logger5.info("Stopping world...");
+    logger4.info("Stopping world...");
     this.setState("stopped");
     if (this.tickInterval) {
       clearInterval(this.tickInterval);
@@ -1812,7 +886,7 @@ var World = class {
       type: "world_stopped",
       timestamp: Date.now()
     });
-    logger5.info("World stopped");
+    logger4.info("World stopped");
   }
   /**
    * Admit an agent to the world
@@ -1827,15 +901,15 @@ var World = class {
       if (!isValid) {
         throw new Error("Agent not registered in on-chain AgentRegistry");
       }
-      logger5.info(`Agent validated on-chain: ${card.name}`);
+      logger4.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}`);
+        logger4.info(`Minting membership NFT for agent: ${card.name}`);
         await this.blockchainClient.mintMembership(walletAddress);
       } else {
-        logger5.info(`Agent already has membership: ${card.name}`);
+        logger4.info(`Agent already has membership: ${card.name}`);
       }
     }
     const profile = {
@@ -1864,7 +938,7 @@ var World = class {
       agentUrl: profile.url,
       data: { name: profile.name, role: profile.role }
     });
-    logger5.info(`Agent admitted: ${profile.name}`, {
+    logger4.info(`Agent admitted: ${profile.name}`, {
       role: profile.role,
       totalAgents: this.agents.size
     });
@@ -1888,7 +962,7 @@ var World = class {
       agentUrl,
       data: { name: agent.name }
     });
-    logger5.info(`Agent removed: ${agent.name}`, {
+    logger4.info(`Agent removed: ${agent.name}`, {
       totalAgents: this.agents.size
     });
   }
@@ -1927,10 +1001,10 @@ var World = class {
     this.autoSaveInterval = setInterval(async () => {
       if (this.persistence) {
         await this.persistence.saveState(this.state);
-        logger5.debug("Auto-saved world state");
+        logger4.debug("Auto-saved world state");
       }
     }, interval);
-    logger5.info(`Auto-save enabled (interval: ${interval}ms)`);
+    logger4.info(`Auto-save enabled (interval: ${interval}ms)`);
   }
   /**
    * Start simulation ticking
@@ -1945,29 +1019,25 @@ var World = class {
         timestamp: Date.now(),
         data: { tick: this.state.tick }
       });
-      logger5.debug(`Tick ${this.state.tick}`);
+      logger4.debug(`Tick ${this.state.tick}`);
       if (this.config.simulation?.maxTicks && this.state.tick >= this.config.simulation.maxTicks) {
-        logger5.info("Max ticks reached, stopping world");
+        logger4.info("Max ticks reached, stopping world");
         await this.stop();
       }
     }, interval);
-    logger5.info(`Simulation ticking enabled (interval: ${interval}ms)`);
+    logger4.info(`Simulation ticking enabled (interval: ${interval}ms)`);
   }
 };
 
-// src/index.ts
-init_CardFetcher();
-
 // src/server/app.ts
-init_logger();
 import express from "express";
-var logger6 = createLogger("WorldServer");
+var logger5 = createLogger("WorldServer");
 function createWorldApp(world) {
   const app = express();
   app.use(express.json());
   app.use(express.urlencoded({ extended: true }));
   app.use((req, res, next) => {
-    logger6.debug(`${req.method} ${req.path}`, {
+    logger5.debug(`${req.method} ${req.path}`, {
       query: req.query,
       ip: req.ip
     });
@@ -1997,10 +1067,10 @@ function createWorldApp(world) {
           error: "agentUrl is required"
         });
       }
-      logger6.info(`Agent join request from: ${agentUrl}`, {
+      logger5.info(`Agent join request from: ${agentUrl}`, {
         wallet: walletAddress || "none"
       });
-      const cardFetcher = new (await Promise.resolve().then(() => (init_CardFetcher(), CardFetcher_exports))).CardFetcher();
+      const cardFetcher = new (await import("./CardFetcher-3QKJ2I5P.js")).CardFetcher();
       const result = await cardFetcher.fetchCard(agentUrl);
       if (!result.success || !result.card) {
         return res.status(400).json({
@@ -2018,7 +1088,7 @@ function createWorldApp(world) {
         }
       });
     } catch (error) {
-      logger6.error("Failed to process join request:", error);
+      logger5.error("Failed to process join request:", error);
       res.status(400).json({
         success: false,
         error: error.message || "Failed to join world"
@@ -2095,7 +1165,7 @@ function createWorldApp(world) {
     });
   });
   app.use((err, req, res, next) => {
-    logger6.error("Server error:", err);
+    logger5.error("Server error:", err);
     res.status(500).json({
       error: "Internal server error",
       message: err.message
@@ -2107,27 +1177,27 @@ 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`);
+    logger5.info(`World "${world.config.name}" server started`);
+    logger5.info(`  http://${host}:${port}`);
+    logger5.info("");
+    logger5.info("Endpoints:");
+    logger5.info(`  GET    /                    - World info`);
+    logger5.info(`  POST   /world/join          - Agent join request`);
+    logger5.info(`  GET    /world/agents        - List agents`);
+    logger5.info(`  GET    /world/state         - World state`);
+    logger5.info(`  POST   /world/start         - Start simulation`);
+    logger5.info(`  POST   /world/stop          - Stop simulation`);
+    logger5.info(`  DELETE /world/agents/:url   - Remove agent`);
   });
   process.on("SIGTERM", async () => {
-    logger6.info("SIGTERM received, shutting down gracefully...");
+    logger5.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...");
+    logger5.info("SIGINT received, shutting down gracefully...");
     server.close(async () => {
       await world.stop();
       process.exit(0);