pmxt-core 2.27.5 → 2.27.7

package/dist/BaseExchange.js

@@ -137,18 +137,6 @@ class PredictionMarketExchange {
      *
      * @param reload - Force a fresh fetch from the API even if markets are already loaded
      * @returns Dictionary of markets indexed by marketId
-     *
-     * @example-ts Stable pagination
-     * await exchange.loadMarkets();
-     * const all = Object.values(exchange.markets);
-     * const page1 = all.slice(0, 100);
-     * const page2 = all.slice(100, 200);
-     *
-     * @example-python Stable pagination
-     * exchange.load_markets()
-     * all = list(exchange.markets.values())
-     * page1 = all[:100]
-     * page2 = all[100:200]
      */
     async loadMarkets(reload = false) {
         if (this.loadedMarkets && !reload) {
@@ -187,20 +175,6 @@ class PredictionMarketExchange {
      * across pages, use `loadMarkets()` and paginate over `Object.values(exchange.markets)`.
      *
      * @note Some exchanges (like Limitless) may only support status 'active' for search results.
-     *
-     * @example-ts Fetch markets
-     * const markets = await exchange.fetchMarkets({ query: 'Trump', limit: 10000 });
-     * console.log(markets[0].title);
-     *
-     * @example-ts Get market by slug
-     * const markets = await exchange.fetchMarkets({ slug: 'will-trump-win' });
-     *
-     * @example-python Fetch markets
-     * markets = exchange.fetch_markets(query='Trump', limit=10000)
-     * print(markets[0].title)
-     *
-     * @example-python Get market by slug
-     * markets = exchange.fetch_markets(slug='will-trump-win')
      */
     async fetchMarkets(params) {
         return this.fetchMarketsImpl(params);
@@ -270,16 +244,6 @@ class PredictionMarketExchange {
      * @returns Array of unified events
      *
      * @note Some exchanges (like Limitless) may only support status 'active' for search results.
-     *
-     * @example-ts Search events
-     * const events = await exchange.fetchEvents({ query: 'Fed Chair' });
-     * const fedEvent = events[0];
-     * console.log(fedEvent.title, fedEvent.markets.length, 'markets');
-     *
-     * @example-python Search events
-     * events = exchange.fetch_events(query='Fed Chair')
-     * fed_event = events[0]
-     * print(fed_event.title, len(fed_event.markets), 'markets')
      */
     async fetchEvents(params) {
         return this.fetchEventsImpl(params ?? {});
@@ -291,15 +255,6 @@ class PredictionMarketExchange {
      * @param params - Lookup parameters (marketId, outcomeId, slug, etc.)
      * @returns A single unified market
      * @throws MarketNotFound if no market matches the parameters
-     *
-     * @example-ts Fetch by market ID
-     * const market = await exchange.fetchMarket({ marketId: '663583' });
-     *
-     * @example-ts Fetch by outcome ID
-     * const market = await exchange.fetchMarket({ outcomeId: '10991849...' });
-     *
-     * @example-python Fetch by market ID
-     * market = exchange.fetch_market(market_id='663583')
      */
     async fetchMarket(params) {
         // Try to fetch from cache first if we have loaded markets and have an ID/slug
@@ -328,12 +283,6 @@ class PredictionMarketExchange {
      * @param params - Lookup parameters (eventId, slug, query)
      * @returns A single unified event
      * @throws EventNotFound if no event matches the parameters
-     *
-     * @example-ts Fetch by event ID
-     * const event = await exchange.fetchEvent({ eventId: 'TRUMP25DEC' });
-     *
-     * @example-python Fetch by event ID
-     * event = exchange.fetch_event(event_id='TRUMP25DEC')
      */
     async fetchEvent(params) {
         const events = await this.fetchEvents(params);
@@ -350,21 +299,6 @@ class PredictionMarketExchange {
      * @param params - OHLCV parameters including resolution (required)
      * @returns Array of price candles
      *
-     * @example-ts Fetch hourly candles
-     * const markets = await exchange.fetchMarkets({ query: 'Trump' });
-     * const outcomeId = markets[0].yes.outcomeId;
-     * const candles = await exchange.fetchOHLCV(outcomeId, {
-     *   resolution: '1h',
-     *   limit: 100
-     * });
-     * console.log(`Latest close: ${candles[candles.length - 1].close}`);
-     *
-     * @example-python Fetch hourly candles
-     * markets = exchange.fetch_markets(query='Trump')
-     * outcome_id = markets[0].yes.outcome_id
-     * candles = exchange.fetch_ohlcv(outcome_id, resolution='1h', limit=100)
-     * print(f"Latest close: {candles[-1].close}")
-     *
      * @notes **CRITICAL**: Use `outcome.outcomeId` (TS) / `outcome.outcome_id` (Python), not the market ID.
      * @notes Polymarket: outcomeId is the CLOB Token ID. Kalshi: outcomeId is the Market Ticker.
      * @notes Resolution options: '1m' | '5m' | '15m' | '1h' | '6h' | '1d'
@@ -378,18 +312,6 @@ class PredictionMarketExchange {
      *
      * @param id - The Outcome ID (outcomeId)
      * @returns Current order book with bids and asks
-     *
-     * @example-ts Fetch order book
-     * const book = await exchange.fetchOrderBook(outcome.outcomeId);
-     * console.log(`Best bid: ${book.bids[0].price}`);
-     * console.log(`Best ask: ${book.asks[0].price}`);
-     * console.log(`Spread: ${(book.asks[0].price - book.bids[0].price) * 100}%`);
-     *
-     * @example-python Fetch order book
-     * book = exchange.fetch_order_book(outcome.outcome_id)
-     * print(f"Best bid: {book.bids[0].price}")
-     * print(f"Best ask: {book.asks[0].price}")
-     * print(f"Spread: {(book.asks[0].price - book.bids[0].price) * 100:.2f}%")
      */
     async fetchOrderBook(id) {
         throw new Error("Method fetchOrderBook not implemented.");
@@ -401,17 +323,6 @@ class PredictionMarketExchange {
      * @param params - Trade filter parameters
      * @returns Array of recent trades
      *
-     * @example-ts Fetch recent trades
-     * const trades = await exchange.fetchTrades(outcome.outcomeId, { limit: 100 });
-     * for (const trade of trades) {
-     *   console.log(`${trade.side} ${trade.amount} @ ${trade.price}`);
-     * }
-     *
-     * @example-python Fetch recent trades
-     * trades = exchange.fetch_trades(outcome.outcome_id, limit=100)
-     * for trade in trades:
-     *     print(f"{trade.side} {trade.amount} @ {trade.price}")
-     *
      * @notes Polymarket requires an API key for trade history. Use fetchOHLCV for public historical data.
      */
     async fetchTrades(id, params) {
@@ -427,46 +338,6 @@ class PredictionMarketExchange {
      *
      * @param params - Order parameters
      * @returns The created order
-     *
-     * @example-ts Place a limit order
-     * const order = await exchange.createOrder({
-     *   marketId: market.marketId,
-     *   outcomeId: market.yes.outcomeId,
-     *   side: 'buy',
-     *   type: 'limit',
-     *   amount: 10,
-     *   price: 0.55
-     * });
-     * console.log(`Order ${order.id}: ${order.status}`);
-     *
-     * @example-ts Place a market order
-     * const order = await exchange.createOrder({
-     *   marketId: market.marketId,
-     *   outcomeId: market.yes.outcomeId,
-     *   side: 'buy',
-     *   type: 'market',
-     *   amount: 5
-     * });
-     *
-     * @example-python Place a limit order
-     * order = exchange.create_order(
-     *     market_id=market.market_id,
-     *     outcome_id=market.yes.outcome_id,
-     *     side='buy',
-     *     type='limit',
-     *     amount=10,
-     *     price=0.55
-     * )
-     * print(f"Order {order.id}: {order.status}")
-     *
-     * @example-python Place a market order
-     * order = exchange.create_order(
-     *     market_id=market.market_id,
-     *     outcome_id=market.yes.outcome_id,
-     *     side='buy',
-     *     type='market',
-     *     amount=5
-     * )
      */
     async createOrder(params) {
         throw new Error("Method createOrder not implemented.");
@@ -481,30 +352,6 @@ class PredictionMarketExchange {
      *
      * @param params - Order parameters (same as createOrder)
      * @returns A BuiltOrder containing the exchange-native payload
-     *
-     * @example-ts Build then inspect a Polymarket order
-     * const built = await exchange.buildOrder({
-     *   marketId: market.marketId,
-     *   outcomeId: market.yes.outcomeId,
-     *   side: 'buy',
-     *   type: 'limit',
-     *   amount: 10,
-     *   price: 0.55
-     * });
-     * console.log(built.signedOrder); // EIP-712 signed order struct
-     * const order = await exchange.submitOrder(built);
-     *
-     * @example-python Build then submit a Polymarket order
-     * built = exchange.build_order(
-     *     market_id=market.market_id,
-     *     outcome_id=market.yes.outcome_id,
-     *     side='buy',
-     *     type='limit',
-     *     amount=10,
-     *     price=0.55
-     * )
-     * print(built.signed_order)
-     * order = exchange.submit_order(built)
      */
     async buildOrder(params) {
         throw new Error('Method buildOrder not implemented.');
@@ -514,16 +361,6 @@ class PredictionMarketExchange {
      *
      * @param built - A BuiltOrder from buildOrder()
      * @returns The submitted order
-     *
-     * @example-ts Submit a pre-built order
-     * const built = await exchange.buildOrder(params);
-     * const order = await exchange.submitOrder(built);
-     * console.log(`Order ${order.id}: ${order.status}`);
-     *
-     * @example-python Submit a pre-built order
-     * built = exchange.build_order(params)
-     * order = exchange.submit_order(built)
-     * print(f"Order {order.id}: {order.status}")
      */
     async submitOrder(built) {
         throw new Error('Method submitOrder not implemented.');
@@ -533,14 +370,6 @@ class PredictionMarketExchange {
      *
      * @param orderId - The order ID to cancel
      * @returns The cancelled order
-     *
-     * @example-ts Cancel an order
-     * const cancelled = await exchange.cancelOrder('order-123');
-     * console.log(cancelled.status); // 'cancelled'
-     *
-     * @example-python Cancel an order
-     * cancelled = exchange.cancel_order('order-123')
-     * print(cancelled.status)  # 'cancelled'
      */
     async cancelOrder(orderId) {
         throw new Error("Method cancelOrder not implemented.");
@@ -550,14 +379,6 @@ class PredictionMarketExchange {
      *
      * @param orderId - The order ID to look up
      * @returns The order details
-     *
-     * @example-ts Fetch order status
-     * const order = await exchange.fetchOrder('order-456');
-     * console.log(`Filled: ${order.filled}/${order.amount}`);
-     *
-     * @example-python Fetch order status
-     * order = exchange.fetch_order('order-456')
-     * print(f"Filled: {order.filled}/{order.amount}")
      */
     async fetchOrder(orderId) {
         throw new Error("Method fetchOrder not implemented.");
@@ -567,23 +388,6 @@ class PredictionMarketExchange {
      *
      * @param marketId - Optional market ID to filter by
      * @returns Array of open orders
-     *
-     * @example-ts Fetch all open orders
-     * const orders = await exchange.fetchOpenOrders();
-     * for (const order of orders) {
-     *   console.log(`${order.side} ${order.amount} @ ${order.price}`);
-     * }
-     *
-     * @example-ts Fetch orders for a specific market
-     * const orders = await exchange.fetchOpenOrders('FED-25JAN');
-     *
-     * @example-python Fetch all open orders
-     * orders = exchange.fetch_open_orders()
-     * for order in orders:
-     *     print(f"{order.side} {order.amount} @ {order.price}")
-     *
-     * @example-python Fetch orders for a specific market
-     * orders = exchange.fetch_open_orders('FED-25JAN')
      */
     async fetchOpenOrders(marketId) {
         throw new Error("Method fetchOpenOrders not implemented.");
@@ -602,19 +406,6 @@ class PredictionMarketExchange {
      *
      * @param address - Optional public wallet address
      * @returns Array of user positions
-     *
-     * @example-ts Fetch positions
-     * const positions = await exchange.fetchPositions();
-     * for (const pos of positions) {
-     *   console.log(`${pos.outcomeLabel}: ${pos.size} @ $${pos.entryPrice}`);
-     *   console.log(`Unrealized P&L: $${pos.unrealizedPnL.toFixed(2)}`);
-     * }
-     *
-     * @example-python Fetch positions
-     * positions = exchange.fetch_positions()
-     * for pos in positions:
-     *     print(f"{pos.outcome_label}: {pos.size} @ ${pos.entry_price}")
-     *     print(f"Unrealized P&L: ${pos.unrealized_pnl:.2f}")
      */
     async fetchPositions(address) {
         throw new Error("Method fetchPositions not implemented.");
@@ -624,14 +415,6 @@ class PredictionMarketExchange {
      *
      * @param address - Optional public wallet address
      * @returns Array of account balances
-     *
-     * @example-ts Fetch balance
-     * const balances = await exchange.fetchBalance();
-     * console.log(`Available: $${balances[0].available}`);
-     *
-     * @example-python Fetch balance
-     * balances = exchange.fetch_balance()
-     * print(f"Available: ${balances[0].available}")
      */
     async fetchBalance(address) {
         throw new Error("Method fetchBalance not implemented.");
@@ -644,16 +427,6 @@ class PredictionMarketExchange {
      * @param side - 'buy' or 'sell'
      * @param amount - Number of contracts to simulate
      * @returns Average execution price, or 0 if insufficient liquidity
-     *
-     * @example-ts Get execution price
-     * const book = await exchange.fetchOrderBook(outcome.outcomeId);
-     * const price = exchange.getExecutionPrice(book, 'buy', 100);
-     * console.log(`Avg price for 100 contracts: ${price}`);
-     *
-     * @example-python Get execution price
-     * book = exchange.fetch_order_book(outcome.outcome_id)
-     * price = exchange.get_execution_price(book, 'buy', 100)
-     * print(f"Avg price for 100 contracts: {price}")
      */
     getExecutionPrice(orderBook, side, amount) {
         return (0, math_1.getExecutionPrice)(orderBook, side, amount);
@@ -665,20 +438,6 @@ class PredictionMarketExchange {
      * @param side - 'buy' or 'sell'
      * @param amount - Number of contracts to simulate
      * @returns Detailed execution result with price, filled amount, and fill status
-     *
-     * @example-ts Get detailed execution price
-     * const book = await exchange.fetchOrderBook(outcome.outcomeId);
-     * const result = exchange.getExecutionPriceDetailed(book, 'buy', 100);
-     * console.log(`Price: ${result.price}`);
-     * console.log(`Filled: ${result.filledAmount}/${100}`);
-     * console.log(`Fully filled: ${result.fullyFilled}`);
-     *
-     * @example-python Get detailed execution price
-     * book = exchange.fetch_order_book(outcome.outcome_id)
-     * result = exchange.get_execution_price_detailed(book, 'buy', 100)
-     * print(f"Price: {result.price}")
-     * print(f"Filled: {result.filled_amount}/100")
-     * print(f"Fully filled: {result.fully_filled}")
      */
     getExecutionPriceDetailed(orderBook, side, amount) {
         return (0, math_1.getExecutionPriceDetailed)(orderBook, side, amount);
@@ -690,36 +449,6 @@ class PredictionMarketExchange {
      * @param markets - Array of markets to filter
      * @param criteria - Filter criteria: string (text search), object (structured), or function (predicate)
      * @returns Filtered array of markets
-     *
-     * @example-ts Simple text search
-     * const filtered = exchange.filterMarkets(markets, 'Trump');
-     *
-     * @example-ts Advanced criteria
-     * const undervalued = exchange.filterMarkets(markets, {
-     *   text: 'Election',
-     *   volume24h: { min: 10000 },
-     *   price: { outcome: 'yes', max: 0.4 }
-     * });
-     *
-     * @example-ts Custom predicate
-     * const volatile = exchange.filterMarkets(markets,
-     *   m => m.yes?.priceChange24h < -0.1
-     * );
-     *
-     * @example-python Simple text search
-     * filtered = exchange.filter_markets(markets, 'Trump')
-     *
-     * @example-python Advanced criteria
-     * undervalued = exchange.filter_markets(markets, {
-     *     'text': 'Election',
-     *     'volume_24h': {'min': 10000},
-     *     'price': {'outcome': 'yes', 'max': 0.4}
-     * })
-     *
-     * @example-python Custom predicate
-     * volatile = exchange.filter_markets(markets,
-     *     lambda m: m.yes and m.yes.price_change_24h < -0.1
-     * )
      */
     filterMarkets(markets, criteria) {
         // Handle predicate function
@@ -856,18 +585,6 @@ class PredictionMarketExchange {
      * @param events - Array of events to filter
      * @param criteria - Filter criteria: string (text search), object (structured), or function (predicate)
      * @returns Filtered array of events
-     *
-     * @example-ts Filter by category
-     * const filtered = exchange.filterEvents(events, {
-     *   category: 'Politics',
-     *   marketCount: { min: 5 }
-     * });
-     *
-     * @example-python Filter by category
-     * filtered = exchange.filter_events(events, {
-     *     'category': 'Politics',
-     *     'market_count': {'min': 5}
-     * })
      */
     filterEvents(events, criteria) {
         // Handle predicate function
@@ -947,17 +664,6 @@ class PredictionMarketExchange {
      * @param id - The Outcome ID to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with the current orderbook state
-     *
-     * @example-ts Stream order book
-     * while (true) {
-     *   const book = await exchange.watchOrderBook(outcome.outcomeId);
-     *   console.log(`Bid: ${book.bids[0]?.price} Ask: ${book.asks[0]?.price}`);
-     * }
-     *
-     * @example-python Stream order book
-     * while True:
-     *     book = exchange.watch_order_book(outcome.outcome_id)
-     *     print(f"Bid: {book.bids[0].price} Ask: {book.asks[0].price}")
      */
     async watchOrderBook(id, limit) {
         throw new Error(`watchOrderBook() is not supported by ${this.name}`);
@@ -974,20 +680,6 @@ class PredictionMarketExchange {
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Promise that resolves with recent trades
-     *
-     * @example-ts Stream trades
-     * while (true) {
-     *   const trades = await exchange.watchTrades(outcome.outcomeId);
-     *   for (const trade of trades) {
-     *     console.log(`${trade.side} ${trade.amount} @ ${trade.price}`);
-     *   }
-     * }
-     *
-     * @example-python Stream trades
-     * while True:
-     *     trades = exchange.watch_trades(outcome.outcome_id)
-     *     for trade in trades:
-     *         print(f"{trade.side} {trade.amount} @ {trade.price}")
      */
     async watchTrades(id, address, since, limit) {
         throw new Error(`watchTrades() is not supported by ${this.name}`);
@@ -1000,17 +692,6 @@ class PredictionMarketExchange {
      * @param address - Public wallet address to watch
      * @param types - Subset of activity to watch (default: all types)
      * @returns Promise that resolves with the latest SubscribedAddressSnapshot snapshot
-     *
-     * @example-ts Stream wallet activity
-     * while (true) {
-     *   const activity = await exchange.watchAddress('0xabc...', ['trades', 'positions']);
-     *   console.log(activity.trades, activity.positions);
-     * }
-     *
-     * @example-python Stream wallet activity
-     * while True:
-     *     activity = exchange.watch_address('0xabc...', ['trades', 'positions'])
-     *     print(activity.trades, activity.positions)
      */
     async watchAddress(address, types) {
         throw new Error(`watchAddress() is not supported by ${this.name}`);
@@ -1019,12 +700,6 @@ class PredictionMarketExchange {
      * Stop watching a previously registered wallet address and release its resource updates.
      *
      * @param address - Public wallet address to stop watching
-     *
-     * @example-ts Stop watching
-     * await exchange.unwatchAddress('0xabc...');
-     *
-     * @example-python Stop watching
-     * exchange.unwatch_address('0xabc...')
      */
     async unwatchAddress(address) {
         throw new Error(`unwatchAddress() is not supported by ${this.name}`);
@@ -1032,12 +707,6 @@ class PredictionMarketExchange {
     /**
      * Close all WebSocket connections and clean up resources.
      * Call this when you're done streaming to properly release connections.
-     *
-     * @example-ts Close connections
-     * await exchange.close();
-     *
-     * @example-python Close connections
-     * exchange.close()
      */
     async close() {
         // Default implementation: no-op

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-09T14:47:02.060Z
+ * Generated at: 2026-04-10T08:47:55.754Z
  * 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-09T14:47:02.060Z
+ * Generated at: 2026-04-10T08:47:55.754Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

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

@@ -21,5 +21,8 @@ export declare class KalshiNormalizer implements IExchangeNormalizer<KalshiRawEv
     }): Balance[];
     private mapOrderStatus;
     private deriveEventDescription;
+    private deriveOutcomeLabel;
+    private cleanLabel;
+    private templateRule;
 }
 export declare function sortRawEvents(events: any[], sort: string): any[];

package/dist/exchanges/kalshi/normalizer.js

@@ -34,10 +34,7 @@ class KalshiNormalizer {
         else if (market.yes_ask) {
             price = (0, price_1.fromKalshiCents)(market.yes_ask);
         }
-        let candidateName = null;
-        if (market.subtitle || market.yes_sub_title) {
-            candidateName = (market.subtitle || market.yes_sub_title);
-        }
+        const candidateName = this.deriveOutcomeLabel(market);
         let priceChange = 0;
         if (market.previous_price_dollars !== undefined && market.last_price_dollars !== undefined) {
             priceChange = market.last_price_dollars - market.previous_price_dollars;
@@ -261,27 +258,64 @@ class KalshiNormalizer {
             return '';
         if (texts.length === 1)
             return texts[0];
-        let prefix = texts[0];
-        for (const t of texts) {
-            while (!t.startsWith(prefix))
-                prefix = prefix.slice(0, -1);
-            if (!prefix)
-                break;
+        const templates = new Map();
+        for (const market of markets) {
+            const rawRule = typeof market?.rules_primary === 'string' ? market.rules_primary : '';
+            if (!rawRule)
+                continue;
+            const candidate = this.deriveOutcomeLabel(market);
+            const templated = this.templateRule(rawRule, candidate);
+            templates.set(templated, (templates.get(templated) ?? 0) + 1);
         }
-        const suffixCandidates = texts.map((t) => t.slice(prefix.length));
-        let suffix = suffixCandidates[0];
-        for (const t of suffixCandidates) {
-            while (!t.endsWith(suffix))
-                suffix = suffix.slice(1);
-            if (!suffix)
-                break;
+        // Only consider templates that actually contain the {x} placeholder so
+        // that a rule we failed to template (e.g. candidate name missing) can
+        // never win the vote and leak a specific name into the event description.
+        if (templates.size > 0) {
+            let bestTemplate = null;
+            let bestCount = 0;
+            for (const [template, count] of templates.entries()) {
+                if (!template.includes('{x}'))
+                    continue;
+                if (count > bestCount) {
+                    bestTemplate = template;
+                    bestCount = count;
+                }
+            }
+            if (bestTemplate)
+                return bestTemplate;
         }
-        if (prefix.length + suffix.length < 20)
-            return texts[0];
-        const variables = texts.map((t) => t.slice(prefix.length, suffix.length ? t.length - suffix.length : undefined));
-        if (new Set(variables).size === 1)
-            return texts[0];
-        return prefix + '{x}' + suffix;
+        return texts[0];
+    }
+    deriveOutcomeLabel(market) {
+        const yesSubtitle = this.cleanLabel(market.yes_sub_title);
+        if (yesSubtitle)
+            return yesSubtitle;
+        const subtitle = this.cleanLabel(market.subtitle);
+        if (subtitle)
+            return subtitle;
+        return null;
+    }
+    cleanLabel(value) {
+        if (typeof value !== 'string')
+            return null;
+        const trimmed = value.trim();
+        if (!trimmed)
+            return null;
+        // Some Kalshi markets use structural subtitles like ":: Democratic".
+        if (trimmed.startsWith('::'))
+            return null;
+        return trimmed;
+    }
+    templateRule(rule, candidateName) {
+        if (!candidateName)
+            return rule;
+        const escaped = candidateName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Unicode-aware word boundaries so non-ASCII candidate names (Jose,
+        // Muller, O'Brien, etc.) still template correctly. JavaScript's \b is
+        // ASCII-only and would silently fail on such names.
+        const matcher = new RegExp(`(?<![\\p{L}\\p{N}])${escaped}(?![\\p{L}\\p{N}])`, 'gu');
+        const replaced = rule.replace(matcher, '{x}');
+        return replaced === rule ? rule : replaced;
     }
 }
 exports.KalshiNormalizer = KalshiNormalizer;

package/dist/exchanges/kalshi/utils.js

@@ -18,11 +18,17 @@ function mapMarketToUnified(event, market) {
     else if (market.yes_ask) {
         price = (0, price_1.fromKalshiCents)(market.yes_ask);
     }
-    // Extract candidate name
-    let candidateName = null;
-    if (market.subtitle || market.yes_sub_title) {
-        candidateName = market.subtitle || market.yes_sub_title;
-    }
+    // Extract candidate name. Prefer explicit outcome subtitle and ignore
+    // structural labels such as ":: Democratic".
+    const cleanLabel = (value) => {
+        if (typeof value !== "string")
+            return null;
+        const trimmed = value.trim();
+        if (!trimmed || trimmed.startsWith("::"))
+            return null;
+        return trimmed;
+    };
+    const candidateName = cleanLabel(market.yes_sub_title) ?? cleanLabel(market.subtitle);
     // Calculate 24h change
     let priceChange = 0;
     if (market.previous_price_dollars !== undefined &&

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-09T14:47:02.110Z
+ * Generated at: 2026-04-10T08:47:55.810Z
  * 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-09T14:47:02.110Z
+ * Generated at: 2026-04-10T08:47:55.810Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.limitlessApiSpec = {