pmxt-core 2.51.1 → 2.51.3

package/API_REFERENCE.md

@@ -1,6 +1,6 @@
 # Prediction Market API Reference
 
-A unified interface for interacting with multiple prediction market exchanges (Kalshi, Polymarket) identically.
+A unified interface for interacting with multiple prediction market exchanges and venues through one interface.
 
 ## Installation & Usage
 
@@ -8,33 +8,22 @@ A unified interface for interacting with multiple prediction market exchanges (K
 npm install pmxtjs
 ```
 
-### Basic Import (CommonJS)
+### Import Styles
 
 ```typescript
-import pmxt from 'pmxtjs';
+import { Polymarket, Kalshi } from 'pmxtjs';
 
-const poly = new pmxt.Polymarket();
-const kalshi = new pmxt.Kalshi();
+const polymarket = new Polymarket();
+const kalshi = new Kalshi();
 ```
 
-### Note for ESM Users
-
-**pmxt is currently CommonJS-only.** If you're using `"type": "module"` in your `package.json`, you have two options:
-
-**Option 1: Default import (recommended)**
 ```typescript
 import pmxt from 'pmxtjs';
-const poly = new pmxt.Polymarket();
-```
 
-**Option 2: Dynamic import**
-```typescript
-const pmxt = await import('pmxtjs');
-const poly = new pmxt.default.Polymarket();
+const polymarket = new pmxt.Polymarket();
+const kalshi = new pmxt.Kalshi();
 ```
 
-**Note**: Named exports like `import { Polymarket } from 'pmxtjs'` will **not work** in ESM projects.
-
 ---
 
 ## Core Methods
@@ -46,8 +35,8 @@ Get active markets from an exchange. This is the unified method for all market f
 - `limit`: Number of results (default: 20)
 - `offset`: Pagination offset
 - `sort`: 'volume' | 'liquidity' | 'newest'
-- `query`: Search text (replaces `searchMarkets`)
-- `slug`: Market slug or ticker (replaces `getMarketsBySlug`)
+- `query`: Search text
+- `slug`: Market slug or ticker
 
 ```typescript
 // 1. Fetch recent markets
@@ -56,13 +45,13 @@ const markets = await polymarket.fetchMarkets({
   sort: 'volume' 
 });
 
-// 2. Search by text (replaces searchMarkets)
+// 2. Search by text
 const results = await kalshi.fetchMarkets({ 
   query: 'Fed rates',
   limit: 10
 });
 
-// 3. Fetch by slug/ticker (replaces getMarketsBySlug)
+// 3. Fetch by slug/ticker
 const market = await polymarket.fetchMarkets({ 
   slug: 'who-will-trump-nominate-as-fed-chair'
 });
@@ -140,7 +129,7 @@ Calculate the volume-weighted average price for a given amount. Returns `0` if t
 
 ```typescript
 const orderBook = await polymarket.fetchOrderBook(outcomeId);
-const price = await polymarket.getExecutionPrice(orderBook, 'buy', 100);
+const price = polymarket.getExecutionPrice(orderBook, 'buy', 100);
 console.log(`Average price for 100 shares: ${price}`);
 ```
 
@@ -148,7 +137,7 @@ console.log(`Average price for 100 shares: ${price}`);
 Calculate detailed execution price information, including partial fills.
 
 ```typescript
-const detailed = await polymarket.getExecutionPriceDetailed(orderBook, 'buy', 100);
+const detailed = polymarket.getExecutionPriceDetailed(orderBook, 'buy', 100);
 console.log(`Average Price: ${detailed.price}`);
 console.log(`Filled Amount: ${detailed.filledAmount}`);
 console.log(`Fully Filled: ${detailed.fullyFilled}`);
@@ -275,10 +264,10 @@ console.log(`Spread: ${(spread * 100).toFixed(2)}%`);
 
 ```typescript
 try {
-  const markets = await kalshi.getMarketsBySlug('INVALID-TICKER');
+  const market = await kalshi.fetchMarket({ slug: 'INVALID-TICKER' });
+  console.log(market.title);
 } catch (error) {
-  // Kalshi: "Event not found: INVALID-TICKER"
-  // Polymarket: Returns empty array []
+  // Throws MarketNotFound when no market matches the lookup
   console.error(error.message);
 }
 ```
@@ -310,7 +299,7 @@ import pmxt, {
 
 ## Authentication & Trading
 
-Both Polymarket and Kalshi support authenticated trading operations. You must provide credentials when initializing the exchange.
+Authenticated trading is available on venues that expose trading APIs. You must provide the venue-specific credentials when initializing the exchange; the examples below show Polymarket and Kalshi.
 
 ### Polymarket Authentication
 

package/bin/pmxt-ensure-server

@@ -39,7 +39,7 @@ function isServerRunning() {
         // Check if process exists
         try {
             process.kill(pid, 0); // Signal 0 checks existence without killing
-            return { running: true, port };
+            return { running: true, pid, port };
         } catch (err) {
             // Process doesn't exist, remove stale lock file
             fs.unlinkSync(LOCK_FILE);
@@ -50,6 +50,26 @@ function isServerRunning() {
     }
 }
 
+/**
+ * Remove the lock we just proved unhealthy, without deleting a newer sidecar's
+ * lock if another launcher won the race and replaced it first.
+ */
+function removeLockFileIfMatches(staleLock) {
+    try {
+        if (!fs.existsSync(LOCK_FILE)) {
+            return false;
+        }
+        const currentLock = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+        if (currentLock.pid === staleLock.pid && currentLock.port === staleLock.port) {
+            fs.unlinkSync(LOCK_FILE);
+            return true;
+        }
+    } catch (err) {
+        return false;
+    }
+    return false;
+}
+
 /**
  * Wait for server to respond to health check
  */
@@ -196,6 +216,7 @@ async function main() {
             } catch (err) {
                 // Server process exists but not responding, try to start fresh
                 console.error('Server process exists but not responding, starting fresh...');
+                removeLockFileIfMatches(serverStatus);
             }
         }
 

package/bin/pmxt-ensure-server.js

@@ -39,7 +39,7 @@ function isServerRunning() {
         // Check if process exists
         try {
             process.kill(pid, 0); // Signal 0 checks existence without killing
-            return { running: true, port };
+            return { running: true, pid, port };
         } catch (err) {
             // Process doesn't exist, remove stale lock file
             fs.unlinkSync(LOCK_FILE);
@@ -50,6 +50,26 @@ function isServerRunning() {
     }
 }
 
+/**
+ * Remove the lock we just proved unhealthy, without deleting a newer sidecar's
+ * lock if another launcher won the race and replaced it first.
+ */
+function removeLockFileIfMatches(staleLock) {
+    try {
+        if (!fs.existsSync(LOCK_FILE)) {
+            return false;
+        }
+        const currentLock = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+        if (currentLock.pid === staleLock.pid && currentLock.port === staleLock.port) {
+            fs.unlinkSync(LOCK_FILE);
+            return true;
+        }
+    } catch (err) {
+        return false;
+    }
+    return false;
+}
+
 /**
  * Wait for server to respond to health check
  */
@@ -85,6 +105,44 @@ function waitForHealth(port, timeout = HEALTH_CHECK_TIMEOUT) {
     });
 }
 
+/**
+ * Wait for the lock file to appear, then health-check the port it specifies.
+ *
+ * The sidecar may bind a non-default port when the default is occupied by an
+ * orphan.  Polling DEFAULT_PORT would be fooled by the orphan, so we wait for
+ * the new sidecar to write its lock file and health-check THAT port.
+ */
+function waitForLockAndHealth(timeout = HEALTH_CHECK_TIMEOUT) {
+    return new Promise((resolve, reject) => {
+        const startTime = Date.now();
+
+        const poll = () => {
+            if (Date.now() - startTime > timeout) {
+                return reject(new Error('Server health check timeout (lock file never appeared)'));
+            }
+
+            try {
+                if (fs.existsSync(LOCK_FILE)) {
+                    const lockData = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+                    const port = lockData.port || DEFAULT_PORT;
+                    // Lock file appeared — now health-check the actual port
+                    const remaining = timeout - (Date.now() - startTime);
+                    waitForHealth(port, Math.max(remaining, 1000))
+                        .then(resolve)
+                        .catch(reject);
+                    return;
+                }
+            } catch (err) {
+                // Lock file partially written or unreadable — retry
+            }
+
+            setTimeout(poll, HEALTH_CHECK_INTERVAL);
+        };
+
+        poll();
+    });
+}
+
 /**
  * Start the PMXT server
  */
@@ -136,8 +194,10 @@ async function startServer() {
     // Detach from parent process
     serverProcess.unref();
 
-    // Wait for server to be ready
-    await waitForHealth(DEFAULT_PORT);
+    // Wait for the sidecar to write its lock file, then health-check
+    // the actual port it bound (which may differ from DEFAULT_PORT if
+    // an orphan sidecar is occupying it).
+    await waitForLockAndHealth();
 }
 
 /**
@@ -156,6 +216,7 @@ async function main() {
             } catch (err) {
                 // Server process exists but not responding, try to start fresh
                 console.error('Server process exists but not responding, starting fresh...');
+                removeLockFileIfMatches(serverStatus);
             }
         }
 

package/dist/BaseExchange.d.ts

@@ -627,8 +627,42 @@ export declare abstract class PredictionMarketExchange {
      * @returns Array of open orders
      */
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    /**
+     * Fetch authenticated user trade history.
+     *
+     * @param params - Optional trade history filters
+     * @param params.outcomeId - Filter by outcome token ID
+     * @param params.marketId - Filter by market ID or ticker
+     * @param params.since - Start timestamp or ISO date
+     * @param params.until - End timestamp or ISO date
+     * @param params.limit - Maximum number of trades
+     * @param params.cursor - Pagination cursor
+     * @returns Array of user trades
+     */
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    /**
+     * Fetch authenticated closed orders.
+     *
+     * @param params - Optional order history filters
+     * @param params.marketId - Filter by market ID or ticker
+     * @param params.since - Start timestamp or ISO date
+     * @param params.until - End timestamp or ISO date
+     * @param params.limit - Maximum number of orders
+     * @param params.cursor - Pagination cursor
+     * @returns Array of closed orders
+     */
     fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
+    /**
+     * Fetch authenticated order history across open and closed orders.
+     *
+     * @param params - Optional order history filters
+     * @param params.marketId - Filter by market ID or ticker
+     * @param params.since - Start timestamp or ISO date
+     * @param params.until - End timestamp or ISO date
+     * @param params.limit - Maximum number of orders
+     * @param params.cursor - Pagination cursor
+     * @returns Array of orders
+     */
     fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     /**
      * Fetch current user positions across all markets.

package/dist/BaseExchange.js

@@ -213,7 +213,13 @@ class PredictionMarketExchange {
             return limit !== undefined ? filtered.slice(start, start + limit) : filtered.slice(start);
         }
         const { limit, offset, ...venueParams } = fetchParams;
-        const markets = await this.fetchMarketsImpl(Object.keys(venueParams).length > 0 ? venueParams : undefined);
+        const hasVenueParams = Object.keys(venueParams).length > 0;
+        const shouldForwardSimpleLimit = limit !== undefined && offset === undefined && !hasVenueParams;
+        const markets = await this.fetchMarketsImpl(shouldForwardSimpleLimit
+            ? { limit }
+            : hasVenueParams
+                ? venueParams
+                : undefined);
         const start = offset ?? 0;
         return limit !== undefined ? markets.slice(start, start + limit) : markets.slice(start);
     }
@@ -357,7 +363,9 @@ class PredictionMarketExchange {
             return limit !== undefined ? filtered.slice(start, start + limit) : filtered.slice(start);
         }
         const { limit, offset, ...venueParams } = fetchParams;
-        const events = await this.fetchEventsImpl(venueParams);
+        const hasVenueParams = Object.keys(venueParams).length > 0;
+        const shouldForwardSimpleLimit = limit !== undefined && offset === undefined && !hasVenueParams;
+        const events = await this.fetchEventsImpl(shouldForwardSimpleLimit ? { limit } : venueParams);
         const start = offset ?? 0;
         return limit !== undefined ? events.slice(start, start + limit) : events.slice(start);
     }
@@ -607,12 +615,46 @@ class PredictionMarketExchange {
     async fetchOpenOrders(marketId) {
         throw new Error("Method fetchOpenOrders not implemented.");
     }
+    /**
+     * Fetch authenticated user trade history.
+     *
+     * @param params - Optional trade history filters
+     * @param params.outcomeId - Filter by outcome token ID
+     * @param params.marketId - Filter by market ID or ticker
+     * @param params.since - Start timestamp or ISO date
+     * @param params.until - End timestamp or ISO date
+     * @param params.limit - Maximum number of trades
+     * @param params.cursor - Pagination cursor
+     * @returns Array of user trades
+     */
     async fetchMyTrades(params) {
         throw new Error("Method fetchMyTrades not implemented.");
     }
+    /**
+     * Fetch authenticated closed orders.
+     *
+     * @param params - Optional order history filters
+     * @param params.marketId - Filter by market ID or ticker
+     * @param params.since - Start timestamp or ISO date
+     * @param params.until - End timestamp or ISO date
+     * @param params.limit - Maximum number of orders
+     * @param params.cursor - Pagination cursor
+     * @returns Array of closed orders
+     */
     async fetchClosedOrders(params) {
         throw new Error("Method fetchClosedOrders not implemented.");
     }
+    /**
+     * Fetch authenticated order history across open and closed orders.
+     *
+     * @param params - Optional order history filters
+     * @param params.marketId - Filter by market ID or ticker
+     * @param params.since - Start timestamp or ISO date
+     * @param params.until - End timestamp or ISO date
+     * @param params.limit - Maximum number of orders
+     * @param params.cursor - Pagination cursor
+     * @returns Array of orders
+     */
     async fetchAllOrders(params) {
         throw new Error("Method fetchAllOrders not implemented.");
     }

package/dist/exchanges/hunch/fetcher.d.ts

@@ -34,6 +34,10 @@ export interface HunchRawMarket {
     /** Present in the schema; absent on the bare list endpoint — optional. */
     volumeUsd?: number;
     totalBets?: number;
+    /** Trailing-24h pool inflow (USD); absent on older API builds — optional. */
+    volume24hUsd?: number;
+    /** Live binary YES/NO odds on the list item; null/absent for N-way markets. */
+    odds?: HunchRawBinaryOdds | null;
     targetMarketCapUsd: number | null;
     outcomes: HunchRawOutcome[] | null;
     headline?: string | null;

package/dist/exchanges/hunch/fetcher.js

@@ -5,6 +5,8 @@ const utils_1 = require("./utils");
 const errors_1 = require("./errors");
 const AGENT_PREFIX = '/api/agent/v1';
 const DEFAULT_LIMIT = 200;
+/** Safety backstop for cursor draining: 50 pages * 200 = 10k markets. */
+const MAX_LIST_PAGES = 50;
 /**
  * HunchFetcher — raw GETs against the live agent API. Hunch reads are keyless,
  * so we hit the HTTP client directly (clearer + more robust than the implicit
@@ -28,6 +30,7 @@ class HunchFetcher {
                 const one = await this.fetchRawMarketById(params.slug);
                 return one ? [one] : [];
             }
+            const explicitLimit = typeof params?.limit === 'number';
             const query = {
                 limit: params?.limit ?? DEFAULT_LIMIT,
             };
@@ -36,12 +39,22 @@ class HunchFetcher {
                 query.status = status;
             if (params?.query)
                 query.token = params.query;
-            const res = await this.ctx.http.get(`${this.baseUrl}${AGENT_PREFIX}/markets`, {
-                params: query,
-                headers: this.ctx.getHeaders(),
-            });
-            const markets = res.data?.markets ?? [];
-            return markets;
+            // A catalog crawl (no explicit limit) follows `nextCursor` to drain
+            // the whole list; an explicit limit fetches just that one page.
+            // MAX_LIST_PAGES is a safety backstop against a runaway cursor loop.
+            const all = [];
+            let cursor;
+            let pages = 0;
+            do {
+                const res = await this.ctx.http.get(`${this.baseUrl}${AGENT_PREFIX}/markets`, {
+                    params: cursor ? { ...query, cursor } : query,
+                    headers: this.ctx.getHeaders(),
+                });
+                all.push(...(res.data?.markets ?? []));
+                cursor = typeof res.data?.nextCursor === 'string' ? res.data.nextCursor : undefined;
+                pages += 1;
+            } while (!explicitLimit && cursor && pages < MAX_LIST_PAGES);
+            return all;
         }
         catch (error) {
             throw errors_1.hunchErrorMapper.mapError(error);

package/dist/exchanges/hunch/utils.d.ts

@@ -45,6 +45,14 @@ export declare function parseHunchSide(outcomeId: string): {
     marketId: string;
     side: string;
 };
+/**
+ * Map a Hunch native category to a pmxt top-level category. Hunch is
+ * crypto-native, so every token/price/on-chain subtype rolls up to "Crypto";
+ * only the manual "event" markets (fights/debates) map elsewhere.
+ */
+export declare function mapHunchCategory(rawCategory: string | undefined): string;
+/** Tags = top category + a human subtype label + the token (deduped, non-empty). */
+export declare function hunchMarketTags(raw: HunchRawMarket): string[];
 /**
  * Shared market normalizer used by both the live fetch path and the (rare)
  * direct-mapping helper. Pulls a Hunch market ref into a {@link UnifiedMarket}.

package/dist/exchanges/hunch/utils.js

@@ -5,6 +5,8 @@ exports.mapHunchStatus = mapHunchStatus;
 exports.mapStatusToHunch = mapStatusToHunch;
 exports.buildOutcomeId = buildOutcomeId;
 exports.parseHunchSide = parseHunchSide;
+exports.mapHunchCategory = mapHunchCategory;
+exports.hunchMarketTags = hunchMarketTags;
 exports.mapHunchMarketToUnified = mapHunchMarketToUnified;
 const market_utils_1 = require("../../utils/market-utils");
 const metadata_1 = require("../../utils/metadata");
@@ -102,6 +104,55 @@ function parseHunchSide(outcomeId) {
         side: outcomeId.slice(idx + 1),
     };
 }
+// ---------------------------------------------------------------------------
+// Category + tags — map Hunch's fine-grained native taxonomy onto pmxt's
+// top-level categories (Crypto / Culture / …) + granular tags, so Hunch
+// markets answer `?category=` filters and match with higher confidence.
+// ---------------------------------------------------------------------------
+/** Hunch native categories that are NOT crypto (manual-resolution markets). */
+const HUNCH_TOP_CATEGORY = {
+    event: 'Culture',
+};
+/**
+ * Map a Hunch native category to a pmxt top-level category. Hunch is
+ * crypto-native, so every token/price/on-chain subtype rolls up to "Crypto";
+ * only the manual "event" markets (fights/debates) map elsewhere.
+ */
+function mapHunchCategory(rawCategory) {
+    return HUNCH_TOP_CATEGORY[rawCategory ?? ''] ?? 'Crypto';
+}
+/** Human-readable granular label per Hunch native category (for tags). */
+const HUNCH_SUBTYPE_LABEL = {
+    market_cap: 'Market Cap',
+    token_mcap_range: 'Market Cap',
+    token_mcap_flip: 'Market Cap',
+    token_mcap_close: 'Market Cap',
+    token_basket_mcap: 'Market Cap',
+    price_direction: 'Price',
+    token_price_range: 'Price',
+    token_return: 'Returns',
+    token_rank_milestone: 'Ranking',
+    chain_volume: 'On-chain Volume',
+    chain_throughput: 'Throughput',
+    chain_stablecoins: 'Stablecoins',
+    launchpad_volume: 'Launchpad',
+    dune_metric: 'On-chain',
+    volume_eta: 'Volume',
+    event: 'Event',
+};
+function titleCaseSlug(s) {
+    return s
+        .split(/[_\s-]+/)
+        .filter(Boolean)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+}
+/** Tags = top category + a human subtype label + the token (deduped, non-empty). */
+function hunchMarketTags(raw) {
+    const top = mapHunchCategory(raw.category);
+    const label = HUNCH_SUBTYPE_LABEL[raw.category] ?? (raw.category ? titleCaseSlug(raw.category) : '');
+    return [...new Set([top, label, raw.tokenSymbol].filter((t) => Boolean(t)))];
+}
 /**
  * Shared market normalizer used by both the live fetch path and the (rare)
  * direct-mapping helper. Pulls a Hunch market ref into a {@link UnifiedMarket}.
@@ -119,6 +170,9 @@ function mapHunchMarketToUnified(raw, odds, ladder) {
     if (!raw || !raw.id)
         return null;
     const marketId = raw.id;
+    // Explicit odds (detail/quote read) win; else fall back to the live odds the
+    // list item now carries — so a bare list-crawl prices binary markets too.
+    const effectiveOdds = odds ?? raw.odds ?? null;
     let outcomes;
     if (Array.isArray(raw.outcomes) && raw.outcomes.length > 0) {
         // N-way parimutuel ladder / date-window market.
@@ -148,9 +202,9 @@ function mapHunchMarketToUnified(raw, odds, ladder) {
     }
     else {
         // Binary YES/NO market.
-        const yesPrice = odds && typeof odds.yesPriceCents === 'number' ? odds.yesPriceCents / 100 : 0;
-        const noPrice = odds && typeof odds.noPriceCents === 'number'
-            ? odds.noPriceCents / 100
+        const yesPrice = effectiveOdds && typeof effectiveOdds.yesPriceCents === 'number' ? effectiveOdds.yesPriceCents / 100 : 0;
+        const noPrice = effectiveOdds && typeof effectiveOdds.noPriceCents === 'number'
+            ? effectiveOdds.noPriceCents / 100
             : yesPrice > 0
                 ? 1 - yesPrice
                 : 0;
@@ -166,13 +220,13 @@ function mapHunchMarketToUnified(raw, odds, ladder) {
         slug: raw.slug,
         outcomes,
         resolutionDate: raw.deadlineAt ? new Date(raw.deadlineAt) : undefined,
-        // Hunch is parimutuel and reports no 24h volume split — surface 0.
-        volume24h: 0,
+        // Trailing-24h pool inflow off the list item (0 when absent / no trades).
+        volume24h: typeof raw.volume24hUsd === 'number' ? raw.volume24hUsd : 0,
         volume: typeof raw.volumeUsd === 'number' ? raw.volumeUsd : undefined,
         liquidity: Number(raw.virtualLiquidityUsd || 0),
         url: raw.links?.app || `${exports.DEFAULT_BASE_URL}/markets/${raw.slug || marketId}`,
-        category: raw.category,
-        tags: raw.tokenSymbol ? [raw.tokenSymbol] : [],
+        category: mapHunchCategory(raw.category),
+        tags: hunchMarketTags(raw),
         status: mapHunchStatus(raw.status),
         sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, exports.HUNCH_PROMOTED_MARKET_KEYS),
     };

package/dist/exchanges/hyperliquid/normalizer.js

@@ -175,7 +175,7 @@ class HyperliquidNormalizer {
             description: outcome.description,
             slug: `hl-${outcomeId}`,
             outcomes,
-            resolutionDate: expiryDate ?? new Date(0),
+            resolutionDate: expiryDate,
             volume24h: raw.volume24h ?? 0,
             liquidity: 0,
             url: buildMarketUrl(outcomeId),

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-06-23T06:11:27.017Z
+ * Generated at: 2026-06-24T09:17:49.567Z
  * 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-06-23T06:11:27.017Z
+ * Generated at: 2026-06-24T09:17:49.567Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

package/dist/exchanges/kalshi/fetcher.js

@@ -64,6 +64,19 @@ class KalshiFetcher {
                 return this.fetchAllWithSeriesTicker(params.series);
             }
             const status = params?.status || 'active';
+            const hasBoundedDefaultRead = status === 'active' &&
+                (params.limit !== undefined || params.cursor !== undefined) &&
+                !params.query &&
+                params.offset === undefined &&
+                params.sort === undefined &&
+                params.searchIn === undefined &&
+                params.category === undefined &&
+                params.tags === undefined &&
+                params.filter === undefined;
+            if (hasBoundedDefaultRead) {
+                const page = await this.fetchRawEventPage(params);
+                return page.events;
+            }
             if (status === 'all') {
                 const openEvents = await this.fetchAllWithStatus('open');
                 const closedEvents = await this.fetchAllWithStatus('closed');

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-06-23T06:11:27.061Z
+ * Generated at: 2026-06-24T09:17:49.606Z
  * 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-06-23T06:11:27.061Z
+ * Generated at: 2026-06-24T09:17:49.606Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.limitlessApiSpec = {

package/dist/exchanges/limitless/index.js

@@ -100,7 +100,10 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             callApi: this.callApi.bind(this),
             getHeaders: () => this.getHeaders(),
         };
-        const limitlessBaseUrl = this.auth?.host || credentials?.baseUrl || utils_1.DEFAULT_LIMITLESS_API_URL;
+        const limitlessBaseUrl = this.auth?.host ||
+            credentials?.baseUrl ||
+            process.env.LIMITLESS_BASE_URL ||
+            utils_1.DEFAULT_LIMITLESS_API_URL;
         this.fetcher = new fetcher_1.LimitlessFetcher(ctx, this.http, this.auth?.getApiKey(), limitlessBaseUrl);
         this.normalizer = new normalizer_1.LimitlessNormalizer();
     }

package/dist/exchanges/metaculus/index.js

@@ -58,7 +58,8 @@ class MetaculusExchange extends BaseExchange_1.PredictionMarketExchange {
         this.apiToken = credentials?.apiToken;
         // Rate-limit conservatively; authenticated users get higher Metaculus quotas
         this.rateLimit = 500;
-        this.baseUrl = credentials?.baseUrl || utils_1.DEFAULT_BASE_URL;
+        this.baseUrl =
+            credentials?.baseUrl || process.env.METACULUS_BASE_URL || utils_1.DEFAULT_BASE_URL;
         const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.metaculusApiSpec, this.baseUrl);
         this.defineImplicitApi(descriptor);
     }

package/dist/exchanges/mock/index.d.ts

@@ -43,7 +43,7 @@ export declare class MockExchange extends PredictionMarketExchange {
     fillOrder(orderId: string, amount?: number): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
-    fetchOpenOrders(_marketId?: string): Promise<Order[]>;
+    fetchOpenOrders(marketId?: string): Promise<Order[]>;
     fetchMyTrades(_params?: {
         outcomeId?: string;
         marketId?: string;