pmxt-core 2.32.2 → 2.32.4

package/dist/exchanges/kalshi/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-04-22T08:35:38.154Z
+ * Generated at: 2026-04-22T16:11:36.646Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {

package/dist/exchanges/kalshi/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kalshiApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-04-22T08:35:38.154Z
+ * Generated at: 2026-04-22T16:11:36.646Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

package/dist/exchanges/limitless/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-04-22T08:35:38.202Z
+ * Generated at: 2026-04-22T16:11:36.689Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const limitlessApiSpec: {

package/dist/exchanges/limitless/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.limitlessApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-04-22T08:35:38.202Z
+ * Generated at: 2026-04-22T16:11:36.689Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.limitlessApiSpec = {

package/dist/exchanges/limitless/utils.js

@@ -38,6 +38,7 @@ function mapMarketToUnified(market) {
         eventId: market.slug,
         title: market.title || market.question,
         description: market.description,
+        slug: market.slug,
         outcomes: outcomes,
         resolutionDate: market.expirationTimestamp ? new Date(market.expirationTimestamp) : new Date(),
         volume24h: Number(market.volumeFormatted || 0),

package/dist/exchanges/myriad/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-04-22T08:35:38.219Z
+ * Generated at: 2026-04-22T16:11:36.707Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const myriadApiSpec: {

package/dist/exchanges/myriad/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.myriadApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-04-22T08:35:38.219Z
+ * Generated at: 2026-04-22T16:11:36.707Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.myriadApiSpec = {

package/dist/exchanges/opinion/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/opinion/opinion-openapi.yaml
- * Generated at: 2026-04-22T08:35:38.228Z
+ * Generated at: 2026-04-22T16:11:36.715Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const opinionApiSpec: {

package/dist/exchanges/opinion/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.opinionApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/opinion/opinion-openapi.yaml
- * Generated at: 2026-04-22T08:35:38.228Z
+ * Generated at: 2026-04-22T16:11:36.715Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.opinionApiSpec = {

package/dist/exchanges/polymarket/api-clob.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-04-22T08:35:38.165Z
+ * Generated at: 2026-04-22T16:11:36.654Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketClobSpec: {

package/dist/exchanges/polymarket/api-clob.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketClobSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-04-22T08:35:38.165Z
+ * Generated at: 2026-04-22T16:11:36.654Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketClobSpec = {

package/dist/exchanges/polymarket/api-data.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-04-22T08:35:38.180Z
+ * Generated at: 2026-04-22T16:11:36.669Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketDataSpec: {

package/dist/exchanges/polymarket/api-data.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketDataSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-04-22T08:35:38.180Z
+ * Generated at: 2026-04-22T16:11:36.669Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketDataSpec = {

package/dist/exchanges/polymarket/api-gamma.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-04-22T08:35:38.178Z
+ * Generated at: 2026-04-22T16:11:36.666Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketGammaSpec: {

package/dist/exchanges/polymarket/api-gamma.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketGammaSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-04-22T08:35:38.178Z
+ * Generated at: 2026-04-22T16:11:36.666Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

package/dist/exchanges/probable/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-04-22T08:35:38.213Z
+ * Generated at: 2026-04-22T16:11:36.695Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const probableApiSpec: {

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-04-22T08:35:38.213Z
+ * Generated at: 2026-04-22T16:11:36.695Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from './exchanges/opinion';
 export * from './exchanges/metaculus';
 export * from './exchanges/smarkets';
 export * from './exchanges/polymarket_us';
+export * from './router';
 export * from './server/app';
 export * from './server/utils/port-manager';
 export * from './server/utils/lock-file';
@@ -28,6 +29,7 @@ import { OpinionExchange } from './exchanges/opinion';
 import { MetaculusExchange } from './exchanges/metaculus';
 import { SmarketsExchange } from './exchanges/smarkets';
 import { PolymarketUSExchange } from './exchanges/polymarket_us';
+import { Router } from './router';
 declare const pmxt: {
     Polymarket: typeof PolymarketExchange;
     Limitless: typeof LimitlessExchange;
@@ -40,6 +42,7 @@ declare const pmxt: {
     Metaculus: typeof MetaculusExchange;
     Smarkets: typeof SmarketsExchange;
     PolymarketUS: typeof PolymarketUSExchange;
+    Router: typeof Router;
 };
 export declare const Polymarket: typeof PolymarketExchange;
 export declare const Limitless: typeof LimitlessExchange;

package/dist/index.js

@@ -32,6 +32,7 @@ __exportStar(require("./exchanges/opinion"), exports);
 __exportStar(require("./exchanges/metaculus"), exports);
 __exportStar(require("./exchanges/smarkets"), exports);
 __exportStar(require("./exchanges/polymarket_us"), exports);
+__exportStar(require("./router"), exports);
 __exportStar(require("./server/app"), exports);
 __exportStar(require("./server/utils/port-manager"), exports);
 __exportStar(require("./server/utils/lock-file"), exports);
@@ -46,6 +47,7 @@ const opinion_1 = require("./exchanges/opinion");
 const metaculus_1 = require("./exchanges/metaculus");
 const smarkets_1 = require("./exchanges/smarkets");
 const polymarket_us_1 = require("./exchanges/polymarket_us");
+const router_1 = require("./router");
 const pmxt = {
     Polymarket: polymarket_1.PolymarketExchange,
     Limitless: limitless_1.LimitlessExchange,
@@ -58,6 +60,7 @@ const pmxt = {
     Metaculus: metaculus_1.MetaculusExchange,
     Smarkets: smarkets_1.SmarketsExchange,
     PolymarketUS: polymarket_us_1.PolymarketUSExchange,
+    Router: router_1.Router,
 };
 exports.Polymarket = polymarket_1.PolymarketExchange;
 exports.Limitless = limitless_1.LimitlessExchange;

package/dist/router/Router.d.ts

@@ -0,0 +1,15 @@
+import type { UnifiedMarket, UnifiedEvent } from '../types';
+import type { RouterOptions, MatchResult, EventMatchResult, PriceComparison, ArbitrageOpportunity, FetchMatchesParams, FetchEventMatchesParams, FetchArbitrageParams, RouterMarketSearchParams, RouterEventSearchParams } from './types';
+export declare class Router {
+    readonly name = "Router";
+    private readonly client;
+    constructor(options: RouterOptions);
+    fetchMatches(params: FetchMatchesParams): Promise<MatchResult[]>;
+    fetchEventMatches(params: FetchEventMatchesParams): Promise<EventMatchResult[]>;
+    compareMarketPrices(params: FetchMatchesParams): Promise<PriceComparison[]>;
+    fetchHedges(params: FetchMatchesParams): Promise<PriceComparison[]>;
+    fetchArbitrage(params?: FetchArbitrageParams): Promise<ArbitrageOpportunity[]>;
+    fetchMarkets(params?: RouterMarketSearchParams): Promise<UnifiedMarket[]>;
+    fetchEvents(params?: RouterEventSearchParams): Promise<UnifiedEvent[]>;
+    createOrder(): Promise<never>;
+}

package/dist/router/Router.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const client_1 = require("./client");
+class Router {
+    name = 'Router';
+    client;
+    constructor(options) {
+        this.client = new client_1.PmxtApiClient(options.apiKey, options.baseUrl);
+    }
+    // -----------------------------------------------------------------------
+    // Core: Cross-exchange market matches
+    // -----------------------------------------------------------------------
+    async fetchMatches(params) {
+        const response = await this.client.getMarketMatches(params);
+        return response.matches ?? [];
+    }
+    // -----------------------------------------------------------------------
+    // Cross-exchange event matches
+    // -----------------------------------------------------------------------
+    async fetchEventMatches(params) {
+        const response = await this.client.getEventMatches(params);
+        return response.matches ?? [];
+    }
+    // -----------------------------------------------------------------------
+    // Price comparison: identity matches with live prices
+    // -----------------------------------------------------------------------
+    async compareMarketPrices(params) {
+        const matches = await this.fetchMatches({
+            ...params,
+            relation: 'identity',
+            includePrices: true,
+        });
+        return matches.map((m) => ({
+            market: m.market,
+            relation: m.relation,
+            confidence: m.confidence,
+            reasoning: m.reasoning,
+            bestBid: m.bestBid,
+            bestAsk: m.bestAsk,
+            venue: m.market.sourceExchange ?? '',
+        }));
+    }
+    // -----------------------------------------------------------------------
+    // Hedging: subset/superset matches with live prices
+    // -----------------------------------------------------------------------
+    async fetchHedges(params) {
+        const matches = await this.fetchMatches({
+            ...params,
+            includePrices: true,
+        });
+        return matches
+            .filter((m) => m.relation === 'subset' || m.relation === 'superset')
+            .map((m) => ({
+            market: m.market,
+            relation: m.relation,
+            confidence: m.confidence,
+            reasoning: m.reasoning,
+            bestBid: m.bestBid,
+            bestAsk: m.bestAsk,
+            venue: m.market.sourceExchange ?? '',
+        }));
+    }
+    // -----------------------------------------------------------------------
+    // Arbitrage: scan identity matches for price spreads
+    // -----------------------------------------------------------------------
+    async fetchArbitrage(params) {
+        const minSpread = params?.minSpread ?? 0;
+        const limit = params?.limit ?? 50;
+        const markets = await this.fetchMarkets({
+            category: params?.category,
+            limit,
+        });
+        const opportunities = [];
+        for (const market of markets) {
+            const matches = await this.fetchMatches({
+                marketId: market.marketId,
+                relation: 'identity',
+                includePrices: true,
+            });
+            if (matches.length === 0)
+                continue;
+            const sourceAsk = market.outcomes[0]?.price ?? null;
+            const sourceBid = sourceAsk; // Best approximation from last price
+            const sourceVenue = market.sourceExchange ?? '';
+            for (const match of matches) {
+                const matchBid = match.bestBid;
+                const matchAsk = match.bestAsk;
+                const matchVenue = match.market.sourceExchange ?? '';
+                if (sourceAsk !== null && matchBid !== null) {
+                    const spread = matchBid - sourceAsk;
+                    if (spread >= minSpread) {
+                        opportunities.push({
+                            marketA: market,
+                            marketB: match.market,
+                            spread,
+                            buyVenue: sourceVenue,
+                            sellVenue: matchVenue,
+                            buyPrice: sourceAsk,
+                            sellPrice: matchBid,
+                        });
+                    }
+                }
+                if (matchAsk !== null && sourceBid !== null) {
+                    const spread = sourceBid - matchAsk;
+                    if (spread >= minSpread) {
+                        opportunities.push({
+                            marketA: match.market,
+                            marketB: market,
+                            spread,
+                            buyVenue: matchVenue,
+                            sellVenue: sourceVenue,
+                            buyPrice: matchAsk,
+                            sellPrice: sourceBid,
+                        });
+                    }
+                }
+            }
+        }
+        opportunities.sort((a, b) => b.spread - a.spread);
+        return opportunities;
+    }
+    // -----------------------------------------------------------------------
+    // Cross-venue search
+    // -----------------------------------------------------------------------
+    async fetchMarkets(params) {
+        const response = await this.client.searchMarkets(params);
+        return response ?? [];
+    }
+    async fetchEvents(params) {
+        const response = await this.client.searchEvents(params);
+        return response ?? [];
+    }
+    // -----------------------------------------------------------------------
+    // Disabled: order routing (future)
+    // -----------------------------------------------------------------------
+    async createOrder() {
+        throw new Error('Router order routing is not yet implemented');
+    }
+}
+exports.Router = Router;

package/dist/router/Router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/router/Router.test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Router_1 = require("./Router");
+const client_1 = require("./client");
+jest.mock('./client');
+const MockedClient = client_1.PmxtApiClient;
+describe('Router', () => {
+    let router;
+    let clientInstance;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        MockedClient.mockClear();
+        router = new Router_1.Router({ apiKey: 'test-key' });
+        clientInstance = MockedClient.mock.instances[0];
+    });
+    describe('constructor', () => {
+        it('has name "Router"', () => {
+            expect(router.name).toBe('Router');
+        });
+        it('does not require exchanges option', () => {
+            expect(() => new Router_1.Router({ apiKey: 'key' })).not.toThrow();
+        });
+    });
+    describe('fetchMatches', () => {
+        it('returns matches from the API using marketId', async () => {
+            const mockMatches = [
+                {
+                    market: { marketId: 'k1', sourceExchange: 'kalshi' },
+                    relation: 'identity',
+                    confidence: 0.95,
+                    reasoning: 'Same resolution condition.',
+                    bestBid: 0.60,
+                    bestAsk: 0.65,
+                },
+            ];
+            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
+            const result = await router.fetchMatches({ marketId: 'm1', relation: 'identity' });
+            expect(clientInstance.getMarketMatches).toHaveBeenCalledWith({ marketId: 'm1', relation: 'identity' });
+            expect(result).toEqual(mockMatches);
+        });
+        it('accepts slug as identifier', async () => {
+            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: [] });
+            await router.fetchMatches({ slug: 'btc-100k' });
+            expect(clientInstance.getMarketMatches).toHaveBeenCalledWith({ slug: 'btc-100k' });
+        });
+        it('returns empty array when no matches', async () => {
+            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({});
+            const result = await router.fetchMatches({ marketId: 'm1' });
+            expect(result).toEqual([]);
+        });
+    });
+    describe('fetchEventMatches', () => {
+        it('returns event matches from the API', async () => {
+            const mockMatches = [
+                { event: { id: 'e2' }, marketMatches: [] },
+            ];
+            clientInstance.getEventMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
+            const result = await router.fetchEventMatches({ eventId: 'e1' });
+            expect(clientInstance.getEventMatches).toHaveBeenCalledWith({ eventId: 'e1' });
+            expect(result).toEqual(mockMatches);
+        });
+    });
+    describe('compareMarketPrices', () => {
+        it('fetches identity matches with includePrices and maps to PriceComparison', async () => {
+            const mockMatches = [
+                {
+                    market: { marketId: 'k1', sourceExchange: 'kalshi', outcomes: [] },
+                    relation: 'identity',
+                    confidence: 0.9,
+                    reasoning: 'Same market.',
+                    bestBid: 0.55,
+                    bestAsk: 0.62,
+                },
+            ];
+            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
+            const result = await router.compareMarketPrices({ marketId: 'm1' });
+            expect(clientInstance.getMarketMatches).toHaveBeenCalledWith({
+                marketId: 'm1',
+                relation: 'identity',
+                includePrices: true,
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0].bestBid).toBe(0.55);
+            expect(result[0].bestAsk).toBe(0.62);
+            expect(result[0].venue).toBe('kalshi');
+            expect(result[0].reasoning).toBe('Same market.');
+        });
+    });
+    describe('fetchHedges', () => {
+        it('returns only subset/superset matches with reasoning', async () => {
+            const mockMatches = [
+                {
+                    market: { marketId: 'k1', sourceExchange: 'kalshi' },
+                    relation: 'identity',
+                    confidence: 0.95,
+                    reasoning: 'Same.',
+                    bestBid: 0.60,
+                    bestAsk: 0.65,
+                },
+                {
+                    market: { marketId: 'k2', sourceExchange: 'kalshi' },
+                    relation: 'subset',
+                    confidence: 0.8,
+                    reasoning: 'Narrower market — nomination implies candidacy.',
+                    bestBid: 0.40,
+                    bestAsk: 0.45,
+                },
+                {
+                    market: { marketId: 'k3', sourceExchange: 'polymarket' },
+                    relation: 'superset',
+                    confidence: 0.7,
+                    reasoning: 'Broader — popular vote does not guarantee election win.',
+                    bestBid: 0.70,
+                    bestAsk: 0.73,
+                },
+            ];
+            clientInstance.getMarketMatches = jest.fn().mockResolvedValue({ matches: mockMatches });
+            const result = await router.fetchHedges({ marketId: 'm1' });
+            expect(result).toHaveLength(2);
+            expect(result[0].relation).toBe('subset');
+            expect(result[0].reasoning).toBe('Narrower market — nomination implies candidacy.');
+            expect(result[1].relation).toBe('superset');
+        });
+    });
+    describe('fetchMarkets', () => {
+        it('returns markets from the API', async () => {
+            const mockMarkets = [{ marketId: 'm1', title: 'BTC' }];
+            clientInstance.searchMarkets = jest.fn().mockResolvedValue(mockMarkets);
+            const result = await router.fetchMarkets({ query: 'bitcoin' });
+            expect(clientInstance.searchMarkets).toHaveBeenCalledWith({ query: 'bitcoin' });
+            expect(result).toEqual(mockMarkets);
+        });
+    });
+    describe('fetchEvents', () => {
+        it('returns events from the API', async () => {
+            const mockEvents = [{ id: 'e1', title: 'Election' }];
+            clientInstance.searchEvents = jest.fn().mockResolvedValue(mockEvents);
+            const result = await router.fetchEvents({ query: 'election' });
+            expect(clientInstance.searchEvents).toHaveBeenCalledWith({ query: 'election' });
+            expect(result).toEqual(mockEvents);
+        });
+    });
+    describe('createOrder', () => {
+        it('throws not implemented error', async () => {
+            await expect(router.createOrder()).rejects.toThrow('Router order routing is not yet implemented');
+        });
+    });
+});

package/dist/router/client.d.ts

@@ -0,0 +1,11 @@
+import type { FetchMatchesParams, FetchEventMatchesParams, RouterMarketSearchParams, RouterEventSearchParams } from './types';
+export declare class PmxtApiClient {
+    private readonly http;
+    constructor(apiKey: string, baseUrl?: string);
+    getMarketMatches(params: FetchMatchesParams): Promise<any>;
+    getEventMatches(params: FetchEventMatchesParams): Promise<any>;
+    searchMarkets(params?: RouterMarketSearchParams): Promise<any>;
+    searchEvents(params?: RouterEventSearchParams): Promise<any>;
+    private request;
+    private mapError;
+}

package/dist/router/client.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PmxtApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("../errors");
+const DEFAULT_BASE_URL = 'https://api.pmxt.dev';
+class PmxtApiClient {
+    http;
+    constructor(apiKey, baseUrl) {
+        this.http = axios_1.default.create({
+            baseURL: baseUrl ?? DEFAULT_BASE_URL,
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 30_000,
+        });
+    }
+    async getMarketMatches(params) {
+        const id = params.marketId ?? params.slug ?? params.url;
+        if (!id)
+            throw new errors_1.BadRequest('One of marketId, slug, or url is required', 'Router');
+        const query = {};
+        if (params.relation)
+            query.relation = params.relation;
+        if (params.minConfidence !== undefined)
+            query.minConfidence = String(params.minConfidence);
+        if (params.limit !== undefined)
+            query.limit = String(params.limit);
+        if (params.includePrices)
+            query.includePrices = 'true';
+        const res = await this.request('GET', `/v0/markets/${encodeURIComponent(id)}/matches`, query);
+        return res.data;
+    }
+    async getEventMatches(params) {
+        const id = params.eventId ?? params.slug;
+        if (!id)
+            throw new errors_1.BadRequest('One of eventId or slug is required', 'Router');
+        const query = {};
+        if (params.relation)
+            query.relation = params.relation;
+        if (params.minConfidence !== undefined)
+            query.minConfidence = String(params.minConfidence);
+        if (params.limit !== undefined)
+            query.limit = String(params.limit);
+        if (params.includePrices)
+            query.includePrices = 'true';
+        const res = await this.request('GET', `/v0/events/${encodeURIComponent(id)}/matches`, query);
+        return res.data;
+    }
+    async searchMarkets(params) {
+        const query = {};
+        if (params?.query)
+            query.q = params.query;
+        if (params?.sourceExchange)
+            query.sourceExchange = params.sourceExchange;
+        if (params?.category)
+            query.category = params.category;
+        if (params?.limit !== undefined)
+            query.limit = String(params.limit);
+        if (params?.offset !== undefined)
+            query.offset = String(params.offset);
+        if (params?.closed)
+            query.closed = 'true';
+        const res = await this.request('GET', '/v0/markets', query);
+        return res.data;
+    }
+    async searchEvents(params) {
+        const query = {};
+        if (params?.query)
+            query.q = params.query;
+        if (params?.sourceExchange)
+            query.sourceExchange = params.sourceExchange;
+        if (params?.category)
+            query.category = params.category;
+        if (params?.limit !== undefined)
+            query.limit = String(params.limit);
+        if (params?.offset !== undefined)
+            query.offset = String(params.offset);
+        if (params?.closed)
+            query.closed = 'true';
+        const res = await this.request('GET', '/v0/events', query);
+        return res.data;
+    }
+    // -----------------------------------------------------------------------
+    // Internal
+    // -----------------------------------------------------------------------
+    async request(method, path, query) {
+        try {
+            const response = await this.http.request({
+                method,
+                url: path,
+                params: query,
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.mapError(error);
+        }
+    }
+    mapError(error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const status = error.response?.status;
+            const message = error.response?.data?.error ??
+                error.response?.data?.message ??
+                error.message;
+            switch (status) {
+                case 401:
+                    return new errors_1.AuthenticationError(message, 'Router');
+                case 404:
+                    return new errors_1.NotFound(message, 'Router');
+                case 429: {
+                    const retryAfter = error.response?.headers?.['retry-after'];
+                    return new errors_1.RateLimitExceeded(message, retryAfter ? parseInt(retryAfter, 10) : undefined, 'Router');
+                }
+                case 400:
+                    return new errors_1.BadRequest(message, 'Router');
+                default:
+                    if (status && status >= 500) {
+                        return new errors_1.ExchangeNotAvailable(`Router API error (${status}): ${message}`, 'Router');
+                    }
+                    return new errors_1.BadRequest(message, 'Router');
+            }
+        }
+        if (error?.code === 'ECONNREFUSED' || error?.code === 'ENOTFOUND' || error?.code === 'ETIMEDOUT') {
+            return new errors_1.NetworkError(`Network error: ${error.message}`, 'Router');
+        }
+        return error instanceof Error ? error : new Error(String(error));
+    }
+}
+exports.PmxtApiClient = PmxtApiClient;

package/dist/router/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/router/client.test.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const client_1 = require("./client");
+const errors_1 = require("../errors");
+jest.mock('axios', () => {
+    const mockInstance = {
+        request: jest.fn(),
+        defaults: { headers: { common: {} } },
+    };
+    const actualAxios = jest.requireActual('axios');
+    const mockAxios = {
+        create: jest.fn(() => mockInstance),
+        isAxiosError: actualAxios.isAxiosError,
+    };
+    return {
+        __esModule: true,
+        ...mockAxios,
+        default: mockAxios,
+    };
+});
+const mockAxiosInstance = axios_1.default.create();
+describe('PmxtApiClient', () => {
+    let client;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockAxiosInstance.request.mockReset();
+        client = new client_1.PmxtApiClient('test-api-key');
+    });
+    it('creates axios instance with Bearer token and default base URL', () => {
+        expect(axios_1.default.create).toHaveBeenCalledWith(expect.objectContaining({
+            baseURL: 'https://api.pmxt.dev',
+            headers: expect.objectContaining({
+                Authorization: 'Bearer test-api-key',
+            }),
+        }));
+    });
+    it('accepts a custom base URL', () => {
+        new client_1.PmxtApiClient('key', 'http://localhost:4111');
+        expect(axios_1.default.create).toHaveBeenCalledWith(expect.objectContaining({
+            baseURL: 'http://localhost:4111',
+        }));
+    });
+    describe('getMarketMatches', () => {
+        it('calls GET /v0/markets/:id/matches with marketId', async () => {
+            const mockData = { data: { market: {}, matches: [{ relation: 'identity' }] } };
+            mockAxiosInstance.request.mockResolvedValue({ data: mockData });
+            const result = await client.getMarketMatches({ marketId: 'abc-123' });
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                method: 'GET',
+                url: '/v0/markets/abc-123/matches',
+                params: {},
+            });
+            expect(result).toEqual(mockData.data);
+        });
+        it('accepts slug as identifier', async () => {
+            mockAxiosInstance.request.mockResolvedValue({
+                data: { data: { matches: [] } },
+            });
+            await client.getMarketMatches({ slug: 'will-btc-hit-100k' });
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                method: 'GET',
+                url: '/v0/markets/will-btc-hit-100k/matches',
+                params: {},
+            });
+        });
+        it('accepts url as identifier', async () => {
+            mockAxiosInstance.request.mockResolvedValue({
+                data: { data: { matches: [] } },
+            });
+            await client.getMarketMatches({ url: 'https://polymarket.com/event/btc' });
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                method: 'GET',
+                url: '/v0/markets/https%3A%2F%2Fpolymarket.com%2Fevent%2Fbtc/matches',
+                params: {},
+            });
+        });
+        it('throws BadRequest when no identifier provided', async () => {
+            await expect(client.getMarketMatches({})).rejects.toThrow(errors_1.BadRequest);
+        });
+        it('passes query params including includePrices', async () => {
+            mockAxiosInstance.request.mockResolvedValue({
+                data: { data: { matches: [] } },
+            });
+            await client.getMarketMatches({
+                marketId: 'abc',
+                relation: 'identity',
+                minConfidence: 0.8,
+                limit: 10,
+                includePrices: true,
+            });
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                method: 'GET',
+                url: '/v0/markets/abc/matches',
+                params: { relation: 'identity', minConfidence: '0.8', limit: '10', includePrices: 'true' },
+            });
+        });
+    });
+    describe('getEventMatches', () => {
+        it('calls GET /v0/events/:id/matches with eventId', async () => {
+            mockAxiosInstance.request.mockResolvedValue({
+                data: { data: { event: {}, matches: [] } },
+            });
+            await client.getEventMatches({ eventId: 'evt-1' });
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                method: 'GET',
+                url: '/v0/events/evt-1/matches',
+                params: {},
+            });
+        });
+        it('throws BadRequest when no identifier provided', async () => {
+            await expect(client.getEventMatches({})).rejects.toThrow(errors_1.BadRequest);
+        });
+    });
+    describe('searchMarkets', () => {
+        it('calls GET /v0/markets with query params', async () => {
+            mockAxiosInstance.request.mockResolvedValue({
+                data: { data: [] },
+            });
+            await client.searchMarkets({
+                query: 'bitcoin',
+                sourceExchange: 'polymarket',
+                limit: 20,
+            });
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                method: 'GET',
+                url: '/v0/markets',
+                params: { q: 'bitcoin', sourceExchange: 'polymarket', limit: '20' },
+            });
+        });
+    });
+    describe('searchEvents', () => {
+        it('calls GET /v0/events with query params', async () => {
+            mockAxiosInstance.request.mockResolvedValue({
+                data: { data: [] },
+            });
+            await client.searchEvents({ query: 'election', category: 'politics' });
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                method: 'GET',
+                url: '/v0/events',
+                params: { q: 'election', category: 'politics' },
+            });
+        });
+    });
+    describe('error mapping', () => {
+        function makeAxiosError(status, data) {
+            const error = new Error('Request failed');
+            error.isAxiosError = true;
+            error.response = { status, data: data ?? { error: `Error ${status}` }, headers: {} };
+            error.config = {};
+            error.toJSON = () => ({});
+            Object.defineProperty(error, '__CANCEL__', { value: false });
+            return error;
+        }
+        it('maps 401 to AuthenticationError', async () => {
+            mockAxiosInstance.request.mockRejectedValue(makeAxiosError(401, { error: 'Invalid API key' }));
+            await expect(client.getMarketMatches({ marketId: 'x' })).rejects.toThrow(errors_1.AuthenticationError);
+        });
+        it('maps 404 to NotFound', async () => {
+            mockAxiosInstance.request.mockRejectedValue(makeAxiosError(404, { error: 'market not found' }));
+            await expect(client.getMarketMatches({ marketId: 'x' })).rejects.toThrow(errors_1.NotFound);
+        });
+        it('maps 429 to RateLimitExceeded', async () => {
+            const err = makeAxiosError(429, { error: 'Too many requests' });
+            err.response.headers = { 'retry-after': '30' };
+            mockAxiosInstance.request.mockRejectedValue(err);
+            await expect(client.getMarketMatches({ marketId: 'x' })).rejects.toThrow(errors_1.RateLimitExceeded);
+        });
+        it('maps 400 to BadRequest', async () => {
+            mockAxiosInstance.request.mockRejectedValue(makeAxiosError(400, { error: 'Invalid relation' }));
+            await expect(client.getMarketMatches({ marketId: 'x' })).rejects.toThrow(errors_1.BadRequest);
+        });
+    });
+});

package/dist/router/index.d.ts

@@ -0,0 +1,3 @@
+export { Router } from './Router';
+export { PmxtApiClient } from './client';
+export * from './types';

package/dist/router/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PmxtApiClient = exports.Router = void 0;
+var Router_1 = require("./Router");
+Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return Router_1.Router; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "PmxtApiClient", { enumerable: true, get: function () { return client_1.PmxtApiClient; } });
+__exportStar(require("./types"), exports);

package/dist/router/types.d.ts

@@ -0,0 +1,74 @@
+import type { UnifiedMarket, UnifiedEvent } from '../types';
+export type MatchRelation = 'identity' | 'subset' | 'superset' | 'overlap' | 'disjoint';
+export interface RouterOptions {
+    apiKey: string;
+    baseUrl?: string;
+}
+export interface MatchResult {
+    market: UnifiedMarket;
+    relation: MatchRelation;
+    confidence: number;
+    reasoning: string | null;
+    bestBid: number | null;
+    bestAsk: number | null;
+}
+export interface EventMatchResult {
+    event: UnifiedEvent;
+    marketMatches: MatchResult[];
+}
+export interface PriceComparison {
+    market: UnifiedMarket;
+    relation: MatchRelation;
+    confidence: number;
+    reasoning: string | null;
+    bestBid: number | null;
+    bestAsk: number | null;
+    venue: string;
+}
+export interface ArbitrageOpportunity {
+    marketA: UnifiedMarket;
+    marketB: UnifiedMarket;
+    spread: number;
+    buyVenue: string;
+    sellVenue: string;
+    buyPrice: number;
+    sellPrice: number;
+}
+export interface FetchMatchesParams {
+    marketId?: string;
+    slug?: string;
+    url?: string;
+    relation?: MatchRelation;
+    minConfidence?: number;
+    limit?: number;
+    includePrices?: boolean;
+}
+export interface FetchEventMatchesParams {
+    eventId?: string;
+    slug?: string;
+    relation?: MatchRelation;
+    minConfidence?: number;
+    limit?: number;
+    includePrices?: boolean;
+}
+export interface FetchArbitrageParams {
+    minSpread?: number;
+    category?: string;
+    limit?: number;
+}
+export interface RouterMarketSearchParams {
+    query?: string;
+    sourceExchange?: string;
+    category?: string;
+    limit?: number;
+    offset?: number;
+    closed?: boolean;
+}
+export interface RouterEventSearchParams {
+    query?: string;
+    sourceExchange?: string;
+    category?: string;
+    limit?: number;
+    offset?: number;
+    closed?: boolean;
+}

package/dist/router/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.32.2",
+  "version": "2.32.4",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,8 +29,8 @@
     "test": "jest -c jest.config.js",
     "server": "tsx watch src/server/index.ts",
     "server:prod": "node dist/server/index.js",
-    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.32.2,library=urllib3",
-    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.32.2,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
+    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.32.4,library=urllib3",
+    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.32.4,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
     "fetch:openapi": "node scripts/fetch-openapi-specs.js",
     "extract:jsdoc": "node ../scripts/extract-jsdoc.js",
     "generate:docs": "npm run extract:jsdoc && node ../scripts/generate-api-docs.js",