@arcaresearch/sdk 0.0.1

package/dist/arca.js

@@ -0,0 +1,780 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arca = void 0;
+const client_1 = require("./client");
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+const websocket_1 = require("./websocket");
+const DEFAULT_BASE_URL = 'https://api.arcaos.io';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TYPEID_RE = /^[a-z]{2,63}_[0-9a-hjkmnp-tv-z]{26}$/i;
+function isIdFormat(value) {
+    return UUID_RE.test(value) || TYPEID_RE.test(value);
+}
+function isApiKeyConfig(config) {
+    return 'apiKey' in config;
+}
+function isTokenConfig(config) {
+    return 'token' in config;
+}
+/**
+ * Decode a JWT payload without verifying the signature.
+ * Used client-side to extract claims like realmId from scoped tokens.
+ */
+function decodeJwtPayload(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3)
+        throw new Error('Invalid JWT format');
+    const payload = parts[1];
+    // atob works in browser; Buffer works in Node
+    const json = typeof atob === 'function'
+        ? atob(payload.replace(/-/g, '+').replace(/_/g, '/'))
+        : Buffer.from(payload, 'base64url').toString('utf-8');
+    return JSON.parse(json);
+}
+/**
+ * The Arca SDK client.
+ *
+ * Usage with API key (backend):
+ * ```typescript
+ * const arca = new Arca({
+ *   apiKey: 'arca_78ae7276_...',
+ *   realm: 'development',
+ * });
+ * await arca.ready();
+ * ```
+ *
+ * Usage with scoped token (frontend):
+ * ```typescript
+ * const arca = Arca.fromToken(scopedJwt);
+ * await arca.ready();
+ * ```
+ */
+class Arca {
+    client;
+    realmInput;
+    resolvedRealmId = null;
+    initPromise = null;
+    /** WebSocket manager for real-time events. */
+    ws;
+    /** @deprecated Use ws.legacySubscribe() or ws.on() / ws.subscribe() instead. */
+    events;
+    constructor(config) {
+        const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        if (isApiKeyConfig(config)) {
+            this.client = new client_1.ArcaClient({
+                credential: config.apiKey,
+                credentialType: 'apiKey',
+                baseUrl: `${baseUrl}/api/v1`,
+            });
+            this.realmInput = config.realm;
+        }
+        else if (isTokenConfig(config)) {
+            this.client = new client_1.ArcaClient({
+                credential: config.token,
+                credentialType: 'token',
+                baseUrl: `${baseUrl}/api/v1`,
+            });
+            this.realmInput = config.realm ?? null;
+            // Try to extract realmId from the token claims
+            if (!this.realmInput) {
+                try {
+                    const claims = decodeJwtPayload(config.token);
+                    if (typeof claims.realmId === 'string') {
+                        this.resolvedRealmId = claims.realmId;
+                    }
+                }
+                catch {
+                    // If we can't decode, we'll try to resolve later
+                }
+            }
+        }
+        else {
+            throw new Error('ArcaConfig must include either apiKey or token');
+        }
+        this.ws = new websocket_1.WebSocketManager({
+            baseUrl: `${baseUrl}/api/v1`,
+            credential: isApiKeyConfig(config) ? config.apiKey : config.token,
+            credentialType: isApiKeyConfig(config) ? 'apiKey' : 'token',
+            getRealmId: () => this.realmId(),
+        });
+        this.events = {
+            subscribe: (optsOrCallback, maybeCallback) => {
+                let opts = {};
+                let callback;
+                if (typeof optsOrCallback === 'function') {
+                    callback = optsOrCallback;
+                }
+                else {
+                    opts = optsOrCallback;
+                    callback = maybeCallback;
+                }
+                return this.ws.legacySubscribe(opts, callback);
+            },
+        };
+    }
+    /**
+     * Create an Arca instance from a scoped JWT token.
+     * The realm is extracted from the token claims automatically.
+     *
+     * @param token - Scoped JWT issued by POST /auth/token
+     * @param opts  - Optional overrides (baseUrl, realm)
+     */
+    static fromToken(token, opts) {
+        return new Arca({
+            token,
+            realm: opts?.realm,
+            baseUrl: opts?.baseUrl,
+        });
+    }
+    /**
+     * Initialize the SDK by resolving the realm slug to an ID.
+     * This is called automatically on the first API call, but can be
+     * called explicitly for eager initialization.
+     */
+    async ready() {
+        if (this.resolvedRealmId)
+            return;
+        if (!this.initPromise) {
+            this.initPromise = this.resolveRealm();
+        }
+        await this.initPromise;
+    }
+    // ---- Arca Objects ----
+    /**
+     * Create a denominated Arca object at the given path (idempotent).
+     * If one already exists with matching type/denomination, it is returned.
+     * Otherwise a new one is created.
+     *
+     * Pass `operationPath` (from the nonce API with separator ":") for
+     * explicit operation-level idempotency, especially when delete+recreate
+     * scenarios are expected.
+     */
+    async createDenominatedArca(opts) {
+        await this.ready();
+        return this.client.post('/objects', {
+            realmId: this.realmId(),
+            path: opts.ref,
+            type: 'denominated',
+            denomination: opts.denomination,
+            metadata: opts.metadata ?? null,
+            operationPath: opts.operationPath ?? null,
+        });
+    }
+    /**
+     * Create an Arca object of any type at the given path (idempotent).
+     *
+     * Pass `operationPath` (from the nonce API with separator ":") for
+     * explicit operation-level idempotency.
+     */
+    async createArca(opts) {
+        await this.ready();
+        return this.client.post('/objects', {
+            realmId: this.realmId(),
+            path: opts.ref,
+            type: opts.type,
+            denomination: opts.denomination ?? null,
+            metadata: opts.metadata ?? null,
+            operationPath: opts.operationPath ?? null,
+        });
+    }
+    /** @deprecated Use createDenominatedArca instead */
+    async ensureDenominatedArca(opts) {
+        return this.createDenominatedArca(opts);
+    }
+    /** @deprecated Use createArca instead */
+    async ensureArca(opts) {
+        return this.createArca(opts);
+    }
+    /**
+     * Delete an Arca object by path. If sweepTo is provided, remaining funds
+     * are transferred to that Arca before deletion.
+     *
+     * If the object is already deleted, returns the existing state.
+     */
+    async ensureDeleted(opts) {
+        await this.ready();
+        return this.client.post('/objects/delete', {
+            realmId: this.realmId(),
+            path: opts.ref,
+            sweepToPath: opts.sweepTo ?? null,
+            liquidatePositions: opts.liquidatePositions ?? false,
+            operationPath: opts.operationPath ?? null,
+        });
+    }
+    /**
+     * Get an Arca object by path.
+     */
+    async getObject(path) {
+        await this.ready();
+        return this.client.get('/objects/by-path', {
+            realmId: this.realmId(),
+            path,
+        });
+    }
+    /**
+     * Get an Arca object's full detail (operations, events, deltas, balances) by ID.
+     */
+    async getObjectDetail(objectId) {
+        await this.ready();
+        return this.client.get(`/objects/${objectId}`);
+    }
+    /**
+     * List Arca objects, optionally filtered by path prefix.
+     */
+    async listObjects(opts) {
+        await this.ready();
+        const params = { realmId: this.realmId() };
+        if (opts?.prefix)
+            params.prefix = opts.prefix;
+        if (opts?.includeDeleted)
+            params.includeDeleted = 'true';
+        return this.client.get('/objects', params);
+    }
+    /**
+     * Get balances for an Arca object by ID.
+     */
+    async getBalances(objectId) {
+        await this.ready();
+        const res = await this.client.get(`/objects/${objectId}/balances`);
+        return res.balances;
+    }
+    /**
+     * Get balances for an Arca object by path.
+     * Resolves the path to an object ID, then fetches balances.
+     */
+    async getBalancesByPath(path) {
+        const obj = await this.getObject(path);
+        return this.getBalances(obj.id);
+    }
+    /**
+     * Browse Arca objects in a folder-like structure.
+     * Returns folders (path prefixes) and objects at the given prefix.
+     */
+    async browseObjects(opts) {
+        await this.ready();
+        const params = {
+            realmId: this.realmId(),
+            prefix: opts?.prefix ?? '/',
+        };
+        if (opts?.includeDeleted)
+            params.includeDeleted = 'true';
+        return this.client.get('/objects/browse', params);
+    }
+    /**
+     * Get version history for an Arca object.
+     */
+    async getObjectVersions(objectId) {
+        await this.ready();
+        return this.client.get(`/objects/${objectId}/versions`);
+    }
+    /**
+     * Get snapshot balances for an Arca object at a specific point in time.
+     */
+    async getSnapshotBalances(objectId, asOf) {
+        await this.ready();
+        return this.client.get(`/objects/${objectId}/snapshot`, {
+            realmId: this.realmId(),
+            asOf,
+        });
+    }
+    // ---- Transfers ----
+    /**
+     * Execute a transfer between two Arca objects.
+     * Settlement is immediate for denominated targets, or async for
+     * targets that require a receiver workflow (e.g. exchange objects).
+     * The operation path serves as the idempotency key.
+     */
+    async transfer(opts) {
+        await this.ready();
+        return this.client.post('/transfer', {
+            realmId: this.realmId(),
+            path: opts.path,
+            sourceArcaPath: opts.from,
+            targetArcaPath: opts.to,
+            amount: opts.amount,
+        });
+    }
+    // ---- Deposits ----
+    /**
+     * Initiate a deposit to a denominated Arca object.
+     * In demo realms, deposits are simulated with a configurable delay.
+     */
+    async deposit(opts) {
+        await this.ready();
+        return this.client.post('/deposit', {
+            realmId: this.realmId(),
+            arcaPath: opts.arcaRef,
+            amount: opts.amount,
+            path: opts.path ?? null,
+            senderAddress: opts.senderAddress ?? null,
+        });
+    }
+    // ---- Withdrawals ----
+    /**
+     * Initiate a withdrawal from a denominated Arca object to an on-chain address.
+     * Requires custody service (on-chain mode) to be active.
+     */
+    async withdrawal(opts) {
+        await this.ready();
+        return this.client.post('/withdrawal', {
+            realmId: this.realmId(),
+            arcaPath: opts.arcaPath,
+            amount: opts.amount,
+            destinationAddress: opts.destinationAddress ?? '',
+            path: opts.path ?? null,
+        });
+    }
+    // ---- Operations ----
+    /**
+     * Get operation detail by ID (includes correlated events and deltas).
+     */
+    async getOperation(operationId) {
+        await this.ready();
+        return this.client.get(`/operations/${operationId}`);
+    }
+    /**
+     * List operations in the realm.
+     */
+    async listOperations(opts) {
+        await this.ready();
+        const params = { realmId: this.realmId() };
+        if (opts?.type)
+            params.type = opts.type;
+        if (opts?.arcaPath)
+            params.arcaPath = opts.arcaPath;
+        if (opts?.path)
+            params.path = opts.path;
+        return this.client.get('/operations', params);
+    }
+    /**
+     * List events in the realm.
+     */
+    async listEvents(opts) {
+        await this.ready();
+        const params = { realmId: this.realmId() };
+        if (opts?.arcaPath)
+            params.arcaPath = opts.arcaPath;
+        if (opts?.path)
+            params.path = opts.path;
+        return this.client.get('/events', params);
+    }
+    /**
+     * Get event detail by ID (includes the parent operation and correlated deltas).
+     */
+    async getEventDetail(eventId) {
+        await this.ready();
+        return this.client.get(`/events/${eventId}`);
+    }
+    // ---- State Deltas ----
+    /**
+     * List state deltas for a given Arca path.
+     */
+    async listDeltas(arcaPath) {
+        await this.ready();
+        return this.client.get('/deltas', {
+            realmId: this.realmId(),
+            arcaPath,
+        });
+    }
+    // ---- Nonces ----
+    /**
+     * Get the next unique nonce for a path prefix.
+     * Useful for constructing unique idempotent operation paths.
+     *
+     * **Important:** Reserve the nonce *before* the operation and store the
+     * resulting path. Reuse the stored path on retry — never call `nonce()`
+     * inline inside an operation call, as each invocation produces a new
+     * unique path and defeats idempotency.
+     *
+     * @param prefix - Path prefix (e.g. '/op/transfer/fund')
+     * @param separator - Override separator between prefix and nonce number.
+     *   Default: '/' if prefix ends with '/', otherwise '-'.
+     *   Use ':' for operation nonces (e.g. '/op/create/wallets/main:1').
+     */
+    async nonce(prefix, separator) {
+        await this.ready();
+        const body = {
+            realmId: this.realmId(),
+            prefix,
+        };
+        if (separator !== undefined) {
+            body.separator = separator;
+        }
+        return this.client.post('/nonce', body);
+    }
+    // ---- Summary ----
+    /**
+     * Get aggregate counts for the realm.
+     */
+    async summary() {
+        await this.ready();
+        return this.client.get('/summary', {
+            realmId: this.realmId(),
+        });
+    }
+    // ---- Aggregation & P&L ----
+    /**
+     * Get aggregated valuation for all objects under a path prefix.
+     * Pass `asOf` to get historical aggregation at a past timestamp.
+     */
+    async getPathAggregation(prefix, options) {
+        await this.ready();
+        const params = {
+            realmId: this.realmId(),
+            prefix,
+        };
+        if (options?.asOf)
+            params.asOf = options.asOf;
+        return this.client.get('/objects/aggregate', params);
+    }
+    /**
+     * Get P&L (profit and loss) for objects under a path prefix over a time range.
+     * Returns starting/ending equity, net inflows/outflows, and calculated P&L.
+     */
+    async getPnl(prefix, from, to) {
+        await this.ready();
+        return this.client.get('/objects/pnl', {
+            realmId: this.realmId(),
+            prefix,
+            from,
+            to,
+        });
+    }
+    /**
+     * Get equity history (time-series) for objects under a path prefix.
+     * Returns equity values sampled evenly over the time range.
+     * The `points` parameter controls how many samples (default 200, max 1000).
+     */
+    async getEquityHistory(prefix, from, to, points = 200) {
+        await this.ready();
+        return this.client.get('/objects/aggregate/history', {
+            realmId: this.realmId(),
+            prefix,
+            from,
+            to,
+            points: String(points),
+        });
+    }
+    /**
+     * Create an aggregation watch that tracks a set of sources.
+     * Returns the watch ID and the initial aggregation.
+     * When the underlying data changes, `aggregation.updated` events are
+     * pushed via WebSocket with the updated aggregation inline.
+     */
+    async createAggregationWatch(sources) {
+        await this.ready();
+        return this.client.post('/aggregations/watch', {
+            realmId: this.realmId(),
+            sources,
+        });
+    }
+    /**
+     * Get the current aggregation for an existing watch.
+     */
+    async getWatchAggregation(watchId) {
+        await this.ready();
+        return this.client.get(`/aggregations/watch/${watchId}`);
+    }
+    /**
+     * Destroy an aggregation watch. The server stops tracking and pushing updates.
+     */
+    async destroyAggregationWatch(watchId) {
+        await this.ready();
+        await this.client.delete(`/aggregations/watch/${watchId}`);
+    }
+    // ---- Reconciliation ----
+    /**
+     * List reconciliation state entries for the realm.
+     */
+    async listReconciliationState() {
+        await this.ready();
+        return this.client.get('/reconciliation', {
+            realmId: this.realmId(),
+        });
+    }
+    // ---- Exchange (Perps) ----
+    /**
+     * Create a Perps Exchange Arca object.
+     * Automatically sets type=exchange, denomination=USD, and exchangeType metadata.
+     */
+    async createPerpsExchange(opts) {
+        await this.ready();
+        return this.client.post('/objects', {
+            realmId: this.realmId(),
+            path: opts.ref,
+            type: 'exchange',
+            denomination: 'USD',
+            metadata: JSON.stringify({ exchangeType: opts.exchangeType || 'hyperliquid' }),
+            operationPath: opts.operationPath,
+        });
+    }
+    /**
+     * Get exchange account state (equity, margin, positions, orders).
+     */
+    async getExchangeState(objectId) {
+        await this.ready();
+        return this.client.get(`/objects/${objectId}/exchange/state`);
+    }
+    /**
+     * Get active asset trading data for an exchange object: max trade sizes,
+     * available margin, mark price, and fee rate. Accounts for leverage,
+     * existing positions, and fees (including builder fee when provided).
+     */
+    async getActiveAssetData(objectId, coin, builderFeeBps) {
+        await this.ready();
+        let url = `/objects/${objectId}/exchange/active-asset-data?coin=${encodeURIComponent(coin)}`;
+        if (builderFeeBps && builderFeeBps > 0)
+            url += `&builderFeeBps=${builderFeeBps}`;
+        return this.client.get(url);
+    }
+    /**
+     * Update leverage for a coin on an exchange Arca object.
+     * Leverage is a per-coin setting that applies to the entire position.
+     * Re-margins any existing position at the new leverage.
+     * Rejects if the account can't afford the increased margin when decreasing leverage.
+     */
+    async updateLeverage(opts) {
+        await this.ready();
+        return this.client.post(`/objects/${opts.objectId}/exchange/leverage`, {
+            coin: opts.coin,
+            leverage: opts.leverage,
+        });
+    }
+    /**
+     * Get leverage settings for a coin (or all coins) on an exchange Arca object.
+     */
+    async getLeverage(objectId, coin) {
+        await this.ready();
+        const params = {};
+        if (coin)
+            params.coin = coin;
+        return this.client.get(`/objects/${objectId}/exchange/leverage`, params);
+    }
+    /**
+     * Get all leverage settings for an exchange Arca object.
+     * Unlike getLeverage(), always returns an array.
+     */
+    async listLeverageSettings(objectId) {
+        const result = await this.getLeverage(objectId);
+        return Array.isArray(result) ? result : [result];
+    }
+    /**
+     * Place an order on an exchange Arca object.
+     * The operation path serves as the idempotency key.
+     */
+    async placeOrder(opts) {
+        await this.ready();
+        return this.client.post(`/objects/${opts.objectId}/exchange/orders`, {
+            realmId: this.realmId(),
+            path: opts.path,
+            coin: opts.coin,
+            side: opts.side,
+            orderType: opts.orderType,
+            size: opts.size,
+            szDenom: opts.szDenom ?? 'token',
+            price: opts.price,
+            leverage: opts.leverage ?? 1,
+            reduceOnly: opts.reduceOnly ?? false,
+            timeInForce: opts.timeInForce ?? 'GTC',
+            ...(opts.builderFeeBps != null && { builderFeeBps: opts.builderFeeBps }),
+            ...(opts.feeTargets != null && { feeTargets: opts.feeTargets }),
+        });
+    }
+    /**
+     * List orders for an exchange Arca object.
+     */
+    async listOrders(objectId, status) {
+        await this.ready();
+        const params = {};
+        if (status)
+            params.status = status;
+        return this.client.get(`/objects/${objectId}/exchange/orders`, params);
+    }
+    /**
+     * Get a specific order with its fills.
+     */
+    async getOrder(objectId, orderId) {
+        await this.ready();
+        return this.client.get(`/objects/${objectId}/exchange/orders/${orderId}`);
+    }
+    /**
+     * Cancel an order on an exchange Arca object.
+     * The operation path serves as the idempotency key.
+     */
+    async cancelOrder(opts) {
+        await this.ready();
+        const params = new URLSearchParams({
+            realmId: this.realmId(),
+            path: opts.path,
+        });
+        return this.client.delete(`/objects/${opts.objectId}/exchange/orders/${opts.orderId}?${params.toString()}`);
+    }
+    /**
+     * List positions for an exchange Arca object.
+     */
+    async listPositions(objectId) {
+        await this.ready();
+        return this.client.get(`/objects/${objectId}/exchange/positions`);
+    }
+    /**
+     * Get market metadata (supported assets).
+     */
+    async getMarketMeta() {
+        await this.ready();
+        return this.client.get('/exchange/market/meta');
+    }
+    /**
+     * Get current mid prices for all assets.
+     */
+    async getMarketMids() {
+        await this.ready();
+        return this.client.get('/exchange/market/mids');
+    }
+    /**
+     * Get L2 order book for a specific coin.
+     */
+    async getOrderBook(coin) {
+        await this.ready();
+        return this.client.get(`/exchange/market/book/${coin}`);
+    }
+    /**
+     * Get OHLCV candle data for a specific coin.
+     */
+    async getCandles(coin, interval, options) {
+        await this.ready();
+        const params = { interval };
+        if (options?.startTime !== undefined)
+            params.startTime = String(options.startTime);
+        if (options?.endTime !== undefined)
+            params.endTime = String(options.endTime);
+        return this.client.get(`/exchange/market/candles/${coin}`, params);
+    }
+    // ---- Invariants ----
+    /**
+     * Run all DB-only invariant checks (I1-I6) via the internal API.
+     * Returns structured results per invariant with pass/fail and violations.
+     */
+    async checkInvariants(limit) {
+        await this.ready();
+        const params = {};
+        if (limit !== undefined)
+            params.limit = String(limit);
+        return this.client.get('/internal/invariant-check', params);
+    }
+    /**
+     * Poll until all operations in the realm have reached a terminal state.
+     * Useful after a batch of async operations (deposits, exchange transfers)
+     * to wait for settlement before running invariant checks.
+     *
+     * @param opts.intervalMs - Polling interval in ms (default: 1000)
+     * @param opts.timeoutMs - Max wait time in ms (default: 120000)
+     * @param opts.onPoll - Optional callback with the current pending count
+     * @returns The number of polls performed
+     */
+    async waitForQuiescence(opts) {
+        await this.ready();
+        const interval = opts?.intervalMs ?? 1000;
+        const timeout = opts?.timeoutMs ?? 120_000;
+        const start = Date.now();
+        let polls = 0;
+        while (true) {
+            const res = await this.listOperations();
+            const pending = res.operations.filter(op => op.state === 'pending');
+            polls++;
+            opts?.onPoll?.(pending.length);
+            if (pending.length === 0)
+                return polls;
+            if (Date.now() - start > timeout) {
+                throw new Error(`Timed out waiting for quiescence after ${timeout}ms. ` +
+                    `${pending.length} operations still pending.`);
+            }
+            await new Promise(r => setTimeout(r, interval));
+        }
+    }
+    /**
+     * Wait for a specific operation to reach a terminal state.
+     * Uses WebSocket events to resolve immediately when the operation updates.
+     * If the WS event arrives without embedded operation data (enrichment failure),
+     * fetches the operation via HTTP as a fallback.
+     */
+    async waitForOperation(operationId, timeoutMs = 30000) {
+        await this.ready();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timeout = setTimeout(() => {
+                cleanup();
+                reject(new Error(`Timed out waiting for operation ${operationId} after ${timeoutMs}ms`));
+            }, timeoutMs);
+            const cleanup = () => {
+                settled = true;
+                clearTimeout(timeout);
+                this.ws.off(types_1.EventType.OperationUpdated, handler);
+            };
+            const isTerminal = (s) => s !== 'pending';
+            const tryResolve = (op) => {
+                if (settled)
+                    return;
+                if (isTerminal(op.state)) {
+                    cleanup();
+                    resolve(op);
+                }
+            };
+            const fetchAndResolve = () => {
+                if (settled)
+                    return;
+                this.getOperation(operationId)
+                    .then(detail => tryResolve(detail.operation))
+                    .catch(() => { });
+            };
+            const handler = (event) => {
+                if (event.entityId !== operationId)
+                    return;
+                if (event.operation) {
+                    tryResolve(event.operation);
+                }
+                else {
+                    fetchAndResolve();
+                }
+            };
+            this.ws.on(types_1.EventType.OperationUpdated, handler);
+            // Check immediately in case it already completed.
+            // If it 404s (Temporal race), retry once after a short delay.
+            this.getOperation(operationId)
+                .then(detail => tryResolve(detail.operation))
+                .catch(() => {
+                setTimeout(fetchAndResolve, 2000);
+            });
+        });
+    }
+    // ---- Internal ----
+    realmId() {
+        if (!this.resolvedRealmId) {
+            throw new Error('Arca SDK not initialized. Call await arca.ready() first.');
+        }
+        return this.resolvedRealmId;
+    }
+    async resolveRealm() {
+        // If already resolved (e.g., from token claims), we're done
+        if (this.resolvedRealmId)
+            return;
+        // If no realm input was provided (and token didn't contain one), error
+        if (!this.realmInput) {
+            throw new Error('No realm specified. Provide a realm in the config or use a scoped token that contains a realmId claim.');
+        }
+        // If it looks like a UUID or a TypeID (e.g. rlm_01h2xcejqtf2nbrexx3vqjhp41), use directly
+        if (isIdFormat(this.realmInput)) {
+            this.resolvedRealmId = this.realmInput;
+            return;
+        }
+        // Otherwise, resolve slug/name/id to ID by listing realms
+        const result = await this.client.get('/realms');
+        const realm = result.realms.find((r) => r.slug === this.realmInput || r.name === this.realmInput || r.id === this.realmInput);
+        if (!realm) {
+            throw new errors_1.NotFoundError(`Realm '${this.realmInput}' not found. Available realms: ${result.realms.map((r) => r.slug).join(', ')}`);
+        }
+        this.resolvedRealmId = realm.id;
+    }
+}
+exports.Arca = Arca;
+//# sourceMappingURL=arca.js.map