@buildaureon/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1030 @@
+// src/adapters/fetch-adapter.ts
+function resolveFetch(custom) {
+  if (custom) return custom.bind(custom);
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("No fetch implementation available in this runtime");
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+function userAgentHeader(version) {
+  return { "X-Aureon-SDK": `@buildaureon/sdk/${version}` };
+}
+
+// src/constants/defaults.ts
+var DEFAULT_API_BASE_URL = "https://api.aureonlabs.network";
+var LOCAL_API_BASE_URL = "http://127.0.0.1:8787";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SDK_VERSION = "0.1.0";
+var SDK_NAME = "@buildaureon/sdk";
+var PRODUCT_NAME = "AUREON";
+var PRODUCT_TAGLINE = "Financial Compass for Robinhood Chain";
+var API_KEY_HEADER = "X-Aureon-Api-Key";
+
+// src/constants/endpoints.ts
+var ENDPOINTS = {
+  healthz: "/healthz",
+  overview: "/overview",
+  portfolio: "/portfolio",
+  portfolioClear: "/portfolio/clear",
+  portfolioSync: "/portfolio/sync",
+  watchdogRefresh: "/watchdog/refresh",
+  objectives: "/objectives",
+  health: "/health",
+  timeline: "/timeline",
+  executions: "/executions",
+  executionsRun: "/executions/run",
+  marketEvents: "/market/events",
+  marketPresets: "/market/presets",
+  vault: "/vault",
+  vaultStatus: "/vault/status",
+  vaultPrepareDeposit: "/vault/prepare-deposit",
+  vaultPrepareWithdraw: "/vault/prepare-withdraw",
+  authNonce: "/auth/nonce",
+  authVerify: "/auth/verify",
+  authLogout: "/auth/logout",
+  authDevLogin: "/auth/dev-login",
+  authMe: "/auth/me",
+  developerApiKeys: "/developer/api-keys"
+};
+function objectivePath(id) {
+  return `${ENDPOINTS.objectives}/${encodeURIComponent(id)}`;
+}
+function objectivePausePath(id) {
+  return `${objectivePath(id)}/pause`;
+}
+function objectiveResumePath(id) {
+  return `${objectivePath(id)}/resume`;
+}
+function objectiveRestorePlanPath(id) {
+  return `${objectivePath(id)}/restore-plan`;
+}
+function objectiveRestorePath(id) {
+  return `${objectivePath(id)}/restore`;
+}
+function developerApiKeyPath(id) {
+  return `${ENDPOINTS.developerApiKeys}/${encodeURIComponent(id)}`;
+}
+
+// src/errors/codes.ts
+var RETRYABLE_CODES = [
+  "NETWORK_ERROR",
+  "TIMEOUT",
+  "RATE_LIMITED",
+  "SERVER_ERROR"
+];
+function isRetryableCode(code) {
+  return RETRYABLE_CODES.includes(code);
+}
+function defaultMessageForStatus(status) {
+  switch (status) {
+    case 400:
+      return "The request failed validation";
+    case 401:
+      return "Authentication is required";
+    case 403:
+      return "Access is forbidden for this resource";
+    case 404:
+      return "The requested resource was not found";
+    case 409:
+      return "The request conflicts with the current resource state";
+    case 429:
+      return "Rate limit exceeded";
+    default:
+      if (status >= 500) return "The server encountered an error";
+      return `Unexpected HTTP status ${status}`;
+  }
+}
+
+// src/errors/base.ts
+var AureonError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(message, code, status = null, details = null) {
+    super(message);
+    this.name = "AureonError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  get retryable() {
+    return isRetryableCode(this.code);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      details: this.details,
+      retryable: this.retryable
+    };
+  }
+};
+var AureonValidationError = class extends AureonError {
+  constructor(message, details = null) {
+    super(message, "VALIDATION_ERROR", 400, details);
+    this.name = "AureonValidationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AureonNotFoundError = class extends AureonError {
+  constructor(message, details = null) {
+    super(message, "NOT_FOUND", 404, details);
+    this.name = "AureonNotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AureonConflictError = class extends AureonError {
+  constructor(message, details = null) {
+    super(message, "CONFLICT", 409, details);
+    this.name = "AureonConflictError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AureonNetworkError = class extends AureonError {
+  constructor(message, details = null) {
+    super(message, "NETWORK_ERROR", null, details);
+    this.name = "AureonNetworkError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AureonTimeoutError = class extends AureonError {
+  constructor(message = "Request timed out", details = null) {
+    super(message, "TIMEOUT", null, details);
+    this.name = "AureonTimeoutError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/errors/http.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractMessage(body) {
+  if (!isRecord(body)) return null;
+  if (typeof body.message === "string") return body.message;
+  if (typeof body.error === "string") return body.error;
+  if (isRecord(body.error) && typeof body.error.message === "string") {
+    return body.error.message;
+  }
+  return null;
+}
+function errorFromHttpStatus(status, body) {
+  const message = extractMessage(body) ?? defaultMessageForStatus(status);
+  const details = isRecord(body) ? body : { body };
+  if (status === 400) return new AureonValidationError(message, details);
+  if (status === 404) return new AureonNotFoundError(message, details);
+  if (status === 409) return new AureonConflictError(message, details);
+  if (status === 401 || status === 403) {
+    return new AureonError(message, "UNAUTHORIZED", status, details);
+  }
+  if (status === 429) {
+    return new AureonError(message, "RATE_LIMITED", status, details);
+  }
+  if (status >= 500) {
+    return new AureonError(message, "SERVER_ERROR", status, details);
+  }
+  return new AureonError(message, "UNEXPECTED_RESPONSE", status, details);
+}
+function isAureonError(value) {
+  return value instanceof AureonError;
+}
+
+// src/transport/url.ts
+function joinUrl(baseUrl, path) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${suffix}`;
+}
+function assertBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (!/^https?:\/\//i.test(trimmed)) {
+    throw new AureonError(
+      "baseUrl must be an absolute http(s) URL",
+      "VALIDATION_ERROR",
+      400,
+      { baseUrl }
+    );
+  }
+  return trimmed;
+}
+function withQuery(path, query) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0 && value !== "") params.set(key, value);
+  }
+  const qs = params.toString();
+  if (!qs) return path;
+  return path.includes("?") ? `${path}&${qs}` : `${path}?${qs}`;
+}
+
+// src/transport/http.ts
+function safeParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { message: text };
+  }
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function isRetryableError(error) {
+  if (error instanceof AureonNetworkError || error instanceof AureonTimeoutError) {
+    return true;
+  }
+  if (error instanceof AureonError) {
+    return typeof error.status === "number" && (error.status >= 500 || error.status === 429);
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function requestJson(transport, path, options = {}) {
+  const url = joinUrl(transport.baseUrl, path);
+  const maxRetries = transport.maxRetries ?? 0;
+  const retryDelayMs = transport.retryDelayMs ?? 250;
+  let attempt = 0;
+  while (true) {
+    attempt += 1;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), transport.timeoutMs);
+    const onAbort = () => controller.abort();
+    if (options.signal) {
+      if (options.signal.aborted) {
+        clearTimeout(timeout);
+        throw new AureonError("Request aborted", "ABORTED");
+      }
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      const token = transport.getAccessToken ? await transport.getAccessToken() : null;
+      const authHeaders = {};
+      if (typeof token === "string" && token.trim().length > 0) {
+        authHeaders.Authorization = `Bearer ${token.trim()}`;
+      }
+      const apiKey = transport.getApiKey ? await transport.getApiKey() : null;
+      if (typeof apiKey === "string" && apiKey.trim().length > 0) {
+        authHeaders["X-Aureon-Api-Key"] = apiKey.trim();
+      }
+      transport.logger?.debug("aureon.request", {
+        method: options.method ?? (options.body !== void 0 ? "POST" : "GET"),
+        path,
+        attempt
+      });
+      const response = await transport.fetchImpl(url, {
+        method: options.method ?? (options.body !== void 0 ? "POST" : "GET"),
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          ...transport.headers,
+          ...authHeaders,
+          ...options.headers
+        },
+        body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      const text = await response.text();
+      const parsed = text.length > 0 ? safeParseJson(text) : null;
+      if (!response.ok) {
+        throw errorFromHttpStatus(response.status, parsed ?? { message: text });
+      }
+      return parsed;
+    } catch (error) {
+      if (error instanceof AureonError && !isRetryableError(error)) {
+        throw error;
+      }
+      if (isAbortError(error)) {
+        const timeoutError = new AureonTimeoutError(
+          "Request timed out or was aborted",
+          { url, timeoutMs: transport.timeoutMs }
+        );
+        if (attempt <= maxRetries) {
+          transport.logger?.warn("aureon.retry", {
+            path,
+            attempt,
+            reason: "timeout"
+          });
+          await sleep(retryDelayMs);
+          continue;
+        }
+        throw timeoutError;
+      }
+      if (error instanceof AureonError) {
+        if (attempt <= maxRetries && isRetryableError(error)) {
+          transport.logger?.warn("aureon.retry", {
+            path,
+            attempt,
+            code: error.code,
+            status: error.status
+          });
+          await sleep(retryDelayMs);
+          continue;
+        }
+        throw error;
+      }
+      const networkError = new AureonNetworkError(
+        error instanceof Error ? error.message : "Network request failed",
+        { url }
+      );
+      if (attempt <= maxRetries) {
+        transport.logger?.warn("aureon.retry", {
+          path,
+          attempt,
+          reason: "network"
+        });
+        await sleep(retryDelayMs);
+        continue;
+      }
+      throw networkError;
+    } finally {
+      clearTimeout(timeout);
+      if (options.signal) options.signal.removeEventListener("abort", onAbort);
+    }
+  }
+}
+
+// src/types/client-options.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+function resolveTimeoutMs(options) {
+  const value = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("timeoutMs must be a positive finite number");
+  }
+  return value;
+}
+function resolveHeaders(options) {
+  const headers = { ...options.headers ?? {} };
+  return headers;
+}
+function resolveMaxRetries(options) {
+  const value = options.maxRetries ?? 0;
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error("maxRetries must be a non-negative integer");
+  }
+  return value;
+}
+function resolveRetryDelayMs(options) {
+  const value = options.retryDelayMs ?? 250;
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error("retryDelayMs must be a non-negative finite number");
+  }
+  return value;
+}
+
+// src/types/market.ts
+function normalizeSymbol(symbol) {
+  return symbol.trim().toUpperCase();
+}
+
+// src/validation/market-input.ts
+function normalizeApplyMarketEventInput(input) {
+  const symbol = normalizeSymbol(input.symbol ?? "");
+  if (!symbol) throw new AureonValidationError("symbol is required");
+  if (!Number.isFinite(input.priceChangeRatio)) {
+    throw new AureonValidationError("priceChangeRatio must be a finite number");
+  }
+  if (input.priceChangeRatio <= -0.95) {
+    throw new AureonValidationError(
+      "priceChangeRatio is too extreme for preview runtime"
+    );
+  }
+  return {
+    ...input,
+    symbol,
+    autoRestore: input.autoRestore !== false,
+    name: input.name?.trim() || void 0,
+    description: input.description?.trim() || void 0
+  };
+}
+
+// src/types/objective.ts
+var OBJECTIVE_KINDS = [
+  "stable_allocation",
+  "balanced_portfolio",
+  "risk_ceiling",
+  "reward_reinvestment"
+];
+var OBJECTIVE_PRIORITIES = [
+  "low",
+  "medium",
+  "high",
+  "critical"
+];
+function isObjectiveKind(value) {
+  return OBJECTIVE_KINDS.includes(value);
+}
+function isObjectivePriority(value) {
+  return OBJECTIVE_PRIORITIES.includes(value);
+}
+
+// src/validation/objective-input.ts
+function buildPolicySummary(kind, targetWeight, tolerance) {
+  const targetPct = (targetWeight * 100).toFixed(1);
+  const tolPct = (tolerance * 100).toFixed(1);
+  switch (kind) {
+    case "stable_allocation":
+      return `Maintain ${targetPct}% stable allocation within \xB1${tolPct}%`;
+    case "balanced_portfolio":
+      return `Hold balanced weights near ${targetPct}% primary sleeve within \xB1${tolPct}%`;
+    case "risk_ceiling":
+      return `Keep portfolio risk at or below configured ceiling with ${tolPct}% buffer`;
+    case "reward_reinvestment":
+      return `Reinvest available rewards toward ${targetPct}% target sleeve`;
+    default:
+      return `Objective policy target ${targetPct}% \xB1${tolPct}%`;
+  }
+}
+function normalizeCreateObjectiveInput(input) {
+  const name = input.name?.trim();
+  if (!name || name.length < 3) {
+    throw new AureonValidationError("Objective name must be at least 3 characters");
+  }
+  if (!isObjectiveKind(input.kind)) {
+    throw new AureonValidationError(`Unsupported objective kind: ${input.kind}`);
+  }
+  if (input.targetWeight < 0 || input.targetWeight > 1) {
+    throw new AureonValidationError("targetWeight must be between 0 and 1");
+  }
+  if (input.tolerance < 0 || input.tolerance > 0.5) {
+    throw new AureonValidationError("tolerance must be between 0 and 0.5");
+  }
+  const priority = input.priority ?? "high";
+  if (!isObjectivePriority(priority)) {
+    throw new AureonValidationError(`Unsupported priority: ${priority}`);
+  }
+  if (input.kind === "balanced_portfolio") {
+    const symbol = input.targetSymbol?.trim().toUpperCase();
+    if (!symbol) {
+      throw new AureonValidationError(
+        "balanced_portfolio requires targetSymbol"
+      );
+    }
+    return {
+      ...input,
+      name,
+      priority,
+      targetSymbol: symbol,
+      // SDK / agent path defaults to Automatic. Explicit "manual" is reserved
+      // for the operator utility Approve UX; not recommended for integrations.
+      automationMode: input.automationMode === "manual" ? "manual" : "auto"
+    };
+  }
+  return {
+    ...input,
+    name,
+    priority,
+    targetSymbol: null,
+    automationMode: input.automationMode === "manual" ? "manual" : "auto"
+  };
+}
+function normalizeUpdateObjectiveInput(input) {
+  const next = { ...input };
+  if (next.name !== void 0) {
+    const name = next.name.trim();
+    if (name.length < 3) {
+      throw new AureonValidationError("Objective name must be at least 3 characters");
+    }
+    next.name = name;
+  }
+  if (next.targetWeight !== void 0) {
+    if (next.targetWeight < 0 || next.targetWeight > 1) {
+      throw new AureonValidationError("targetWeight must be between 0 and 1");
+    }
+  }
+  if (next.tolerance !== void 0) {
+    if (next.tolerance < 0 || next.tolerance > 0.5) {
+      throw new AureonValidationError("tolerance must be between 0 and 0.5");
+    }
+  }
+  if (next.priority !== void 0 && !isObjectivePriority(next.priority)) {
+    throw new AureonValidationError(`Unsupported priority: ${next.priority}`);
+  }
+  if (next.automationMode !== void 0) {
+    throw new AureonValidationError(
+      "automationMode cannot be changed after create: recreate the objective instead"
+    );
+  }
+  return next;
+}
+function assertId(value, label) {
+  if (!value || typeof value !== "string" || value.trim().length < 8) {
+    throw new AureonValidationError(`Invalid ${label}`);
+  }
+}
+
+// src/client/aureon-client.ts
+var AureonClient = class {
+  transport;
+  constructor(options = {}) {
+    const baseUrl = options.baseUrl ?? DEFAULT_API_BASE_URL;
+    const staticToken = options.authToken;
+    const getAccessToken = options.getAccessToken ?? (staticToken ? () => staticToken : void 0);
+    const staticApiKey = options.apiKey;
+    const getApiKey = options.getApiKey ?? (staticApiKey ? () => staticApiKey : void 0);
+    this.transport = {
+      baseUrl: assertBaseUrl(baseUrl),
+      fetchImpl: resolveFetch(options.fetch),
+      headers: {
+        ...userAgentHeader(SDK_VERSION),
+        ...resolveHeaders({ ...options})
+      },
+      timeoutMs: resolveTimeoutMs(options),
+      maxRetries: resolveMaxRetries(options),
+      retryDelayMs: resolveRetryDelayMs(options),
+      logger: options.logger,
+      getAccessToken,
+      getApiKey
+    };
+  }
+  /** Returns the resolved API base URL. */
+  get baseUrl() {
+    return this.transport.baseUrl;
+  }
+  /** Health probe for connectivity checks. No auth required. */
+  async ping() {
+    return requestJson(this.transport, ENDPOINTS.healthz);
+  }
+  /**
+   * Requests a single-use wallet auth nonce/message for the given address.
+   * No Bearer token required.
+   */
+  async getAuthNonce(address) {
+    const trimmed = address?.trim();
+    if (!trimmed) {
+      throw new AureonValidationError("address is required");
+    }
+    return requestJson(
+      this.transport,
+      withQuery(ENDPOINTS.authNonce, { address: trimmed })
+    );
+  }
+  /**
+   * Verifies a wallet signature and returns a Bearer session.
+   * No Bearer token required on the request itself.
+   */
+  async verifyWallet(input) {
+    const address = input.address?.trim();
+    const message = input.message?.trim();
+    const signature = input.signature?.trim();
+    if (!address || !message || !signature) {
+      throw new AureonValidationError(
+        "address, message, and signature are required"
+      );
+    }
+    return requestJson(this.transport, ENDPOINTS.authVerify, {
+      method: "POST",
+      body: { address, message, signature }
+    });
+  }
+  /**
+   * Local preview login without a wallet signature.
+   * Only succeeds when the backend has `AUREON_ALLOW_DEV_LOGIN=1`.
+   */
+  async devLogin() {
+    return requestJson(this.transport, ENDPOINTS.authDevLogin, {
+      method: "POST"
+    });
+  }
+  /** Revokes the current Bearer session on the server. */
+  async logout() {
+    return requestJson(this.transport, ENDPOINTS.authLogout, {
+      method: "POST"
+    });
+  }
+  /** Returns the wallet bound to the current Bearer session. Auth required. */
+  async me() {
+    return requestJson(this.transport, ENDPOINTS.authMe);
+  }
+  /**
+   * Creates and activates a Financial Compass Objective (FCO).
+   * SDK / agent path always prefers Automatic (`automationMode` omitted → `"auto"`).
+   * Mode cannot be changed later via `updateObjective`; recreate instead.
+   * Passing `"manual"` is reserved for the operator utility Approve UX.
+   * Auth required.
+   */
+  async createObjective(input) {
+    const body = normalizeCreateObjectiveInput(input);
+    return requestJson(this.transport, ENDPOINTS.objectives, {
+      method: "POST",
+      body
+    });
+  }
+  /** Lists objectives for the authenticated wallet. Auth required. */
+  async listObjectives() {
+    const result = await requestJson(
+      this.transport,
+      ENDPOINTS.objectives
+    );
+    return result.objectives;
+  }
+  /** Fetches a single objective by id. Auth required. */
+  async getObjective(id) {
+    assertId(id, "objective id");
+    return requestJson(this.transport, objectivePath(id));
+  }
+  /**
+   * Applies a partial update to an objective policy or metadata.
+   * Does **not** accept `automationMode` (mode is locked at create).
+   * Auth required.
+   */
+  async updateObjective(id, input) {
+    assertId(id, "objective id");
+    const body = normalizeUpdateObjectiveInput(input);
+    return requestJson(this.transport, objectivePath(id), {
+      method: "PATCH",
+      body
+    });
+  }
+  /** Pauses continuous evaluation for an objective. Auth required. */
+  async pauseObjective(id) {
+    assertId(id, "objective id");
+    return requestJson(this.transport, objectivePausePath(id), {
+      method: "POST"
+    });
+  }
+  /** Resumes evaluation for a paused objective. Auth required. */
+  async resumeObjective(id) {
+    assertId(id, "objective id");
+    return requestJson(this.transport, objectiveResumePath(id), {
+      method: "POST"
+    });
+  }
+  /** Returns health for one objective or all objectives when id is omitted. Auth required. */
+  async getHealth(objectiveId) {
+    const path = withQuery(ENDPOINTS.health, { objectiveId });
+    const result = await requestJson(
+      this.transport,
+      path
+    );
+    return result.health;
+  }
+  /** Returns timeline events, optionally filtered by objective. Auth required. */
+  async getTimeline(objectiveId) {
+    const path = withQuery(ENDPOINTS.timeline, { objectiveId });
+    const result = await requestJson(
+      this.transport,
+      path
+    );
+    return result.events;
+  }
+  /** Returns the current portfolio snapshot for the wallet. Auth required. */
+  async getPortfolio() {
+    return requestJson(this.transport, ENDPOINTS.portfolio);
+  }
+  /**
+   * Replaces the wallet capital book with the provided positions.
+   * Auth required. Does not invent holdings: every row must be supplied.
+   */
+  async setPortfolio(positions) {
+    if (!Array.isArray(positions) || positions.length === 0) {
+      throw new AureonValidationError("positions must be a non-empty array");
+    }
+    const result = await requestJson(
+      this.transport,
+      ENDPOINTS.portfolio,
+      { method: "PUT", body: { positions } }
+    );
+    return result.portfolio;
+  }
+  /**
+   * Clears all capital-book positions for the authenticated wallet.
+   * Auth required. Does not invent seeded holdings.
+   */
+  async clearPortfolio() {
+    const result = await requestJson(
+      this.transport,
+      ENDPOINTS.portfolioClear,
+      { method: "POST" }
+    );
+    return result.portfolio;
+  }
+  /**
+   * Replaces the capital book with on-chain balances for the session wallet
+   * (Robinhood Chain via the AUREON API). Vault balances merge into the book.
+   * Requires a wallet Bearer session; SDK clients should also send an API key
+   * when keys are enforced. Does not invent holdings; only positive balances
+   * returned by the API.
+   */
+  async syncPortfolio() {
+    return requestJson(this.transport, ENDPOINTS.portfolioSync, {
+      method: "POST"
+    });
+  }
+  /**
+   * Refreshes portfolio marks from live public market data, re-evaluates
+   * objectives, optionally fires breach webhooks, and returns restore suggestions.
+   * Auth required.
+   */
+  async refreshWatchdog() {
+    return requestJson(this.transport, ENDPOINTS.watchdogRefresh, {
+      method: "POST"
+    });
+  }
+  /** Returns dashboard overview aggregates. Auth required. */
+  async getOverview() {
+    return requestJson(this.transport, ENDPOINTS.overview);
+  }
+  /**
+   * Applies a controlled market event to portfolio marks.
+   * When autoRestore is true, the API evaluates health and may run staged restorative execution.
+   * Auth required.
+   */
+  async applyMarketEvent(input) {
+    const body = normalizeApplyMarketEventInput(input);
+    return requestJson(this.transport, ENDPOINTS.marketEvents, {
+      method: "POST",
+      body
+    });
+  }
+  /** Lists controlled market event presets. Auth required. */
+  async listMarketPresets() {
+    const result = await requestJson(
+      this.transport,
+      ENDPOINTS.marketPresets
+    );
+    return result.presets;
+  }
+  /**
+   * Returns the restore plan for an objective (wrap ETH, unwrap WETH, or vault swap).
+   * Auth required.
+   */
+  async getRestorePlan(objectiveId) {
+    assertId(objectiveId, "objective id");
+    const result = await requestJson(
+      this.transport,
+      objectiveRestorePlanPath(objectiveId)
+    );
+    return result.plan;
+  }
+  /**
+   * Runs restorative execution for an objective currently outside policy.
+   * Vault Sell A→Buy B when configured. ETH↔WETH wrap/unwrap is client-side
+   * via getRestorePlan; this endpoint rejects those with action details.
+   * Auth required.
+   */
+  async runExecution(objectiveId) {
+    assertId(objectiveId, "objective id");
+    return requestJson(this.transport, ENDPOINTS.executionsRun, {
+      method: "POST",
+      body: { objectiveId }
+    });
+  }
+  /**
+   * Runs vault-backed restorative execution for an objective outside policy.
+   * Auth required.
+   */
+  async restoreObjective(objectiveId) {
+    assertId(objectiveId, "objective id");
+    return requestJson(this.transport, objectiveRestorePath(objectiveId), {
+      method: "POST"
+    });
+  }
+  /** Lists recent execution receipts. Auth required. */
+  async listExecutions(objectiveId) {
+    const path = withQuery(ENDPOINTS.executions, { objectiveId });
+    const result = await requestJson(
+      this.transport,
+      path
+    );
+    return result.executions;
+  }
+  /** Returns the vault overview for the authenticated wallet. Auth required. */
+  async getVault() {
+    return requestJson(this.transport, ENDPOINTS.vault);
+  }
+  /** Returns compact vault funding status before restore. Auth required. */
+  async getVaultStatus() {
+    return requestJson(this.transport, ENDPOINTS.vaultStatus);
+  }
+  /**
+   * Prepares wallet-signed calldata steps for a vault deposit.
+   * Auth required.
+   */
+  async prepareVaultDeposit(input) {
+    const symbol = input.symbol?.trim();
+    const amount = input.amount?.trim();
+    if (!symbol) {
+      throw new AureonValidationError(
+        "symbol is required (ETH or an allowlisted ERC-20)"
+      );
+    }
+    if (!amount) {
+      throw new AureonValidationError("amount is required");
+    }
+    return requestJson(this.transport, ENDPOINTS.vaultPrepareDeposit, {
+      method: "POST",
+      body: { symbol: symbol.toUpperCase(), amount }
+    });
+  }
+  /**
+   * Prepares wallet-signed calldata steps for a vault withdraw (any allowlisted ERC-20).
+   * Auth required.
+   */
+  async prepareVaultWithdraw(input) {
+    const symbol = (input.symbol?.trim() || "WETH").toUpperCase();
+    const amount = input.amount?.trim();
+    if (!amount) {
+      throw new AureonValidationError("amount is required");
+    }
+    if (symbol === "ETH") {
+      throw new AureonValidationError(
+        'withdraw symbol cannot be "ETH", use WETH'
+      );
+    }
+    return requestJson(this.transport, ENDPOINTS.vaultPrepareWithdraw, {
+      method: "POST",
+      body: { symbol, amount }
+    });
+  }
+  /**
+   * Lists SDK API keys for the authenticated wallet.
+   * Used by the operator utility Developer page.
+   */
+  async listApiKeys() {
+    const result = await requestJson(
+      this.transport,
+      ENDPOINTS.developerApiKeys
+    );
+    return result.keys;
+  }
+  /**
+   * Creates an SDK API key. `secret` is returned once; store it immediately.
+   */
+  async createApiKey(name) {
+    const trimmed = name.trim();
+    if (trimmed.length < 2) {
+      throw new AureonValidationError("name must be at least 2 characters");
+    }
+    return requestJson(this.transport, ENDPOINTS.developerApiKeys, {
+      method: "POST",
+      body: { name: trimmed }
+    });
+  }
+  /** Revokes (deletes) an SDK API key owned by this wallet. */
+  async revokeApiKey(keyId) {
+    assertId(keyId, "api key id");
+    return requestJson(this.transport, developerApiKeyPath(keyId), {
+      method: "DELETE"
+    });
+  }
+  /** Toggles the status (active/paused) of an SDK API key owned by this wallet. */
+  async toggleApiKey(keyId) {
+    assertId(keyId, "api key id");
+    return requestJson(this.transport, `${developerApiKeyPath(keyId)}/toggle`, {
+      method: "POST"
+    });
+  }
+};
+
+// src/client/factory.ts
+function createAureonClient(options = {}) {
+  return new AureonClient({
+    baseUrl: options.baseUrl ?? DEFAULT_API_BASE_URL,
+    ...options
+  });
+}
+function createLocalAureonClient(overrides = {}) {
+  return new AureonClient({
+    ...overrides,
+    baseUrl: overrides.baseUrl ?? LOCAL_API_BASE_URL
+  });
+}
+
+// src/auth/session.ts
+function createSessionTokenProvider(initialToken) {
+  let token = initialToken ?? null;
+  return {
+    getAccessToken: () => token,
+    setToken: (next) => {
+      token = next;
+    },
+    clear: () => {
+      token = null;
+    }
+  };
+}
+
+// src/formatting/display.ts
+function formatUsd(value) {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    maximumFractionDigits: 2
+  }).format(value);
+}
+function formatWeight(weight) {
+  return `${(weight * 100).toFixed(1)}%`;
+}
+function healthTone(state) {
+  switch (state) {
+    case "healthy":
+      return "positive";
+    case "warning":
+      return "caution";
+    case "violation":
+      return "critical";
+    case "paused":
+      return "neutral";
+    default:
+      return "neutral";
+  }
+}
+function formatSignedPercent(ratio) {
+  const pct = ratio * 100;
+  const sign = pct > 0 ? "+" : "";
+  return `${sign}${pct.toFixed(1)}%`;
+}
+function formatIsoTime(iso) {
+  try {
+    return new Intl.DateTimeFormat("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    }).format(new Date(iso));
+  } catch {
+    return iso;
+  }
+}
+
+// src/types/health.ts
+function isHealthState(value) {
+  return ["healthy", "warning", "violation", "paused"].includes(value);
+}
+function healthRank(state) {
+  switch (state) {
+    case "healthy":
+      return 0;
+    case "warning":
+      return 1;
+    case "paused":
+      return 2;
+    case "violation":
+      return 3;
+    default:
+      return 99;
+  }
+}
+function pickWorstHealth(records) {
+  if (records.length === 0) return null;
+  return [...records].sort((a, b) => healthRank(b.state) - healthRank(a.state))[0] ?? null;
+}
+
+// src/types/timeline.ts
+var TIMELINE_EVENT_TYPES = [
+  "objective_created",
+  "objective_updated",
+  "objective_paused",
+  "objective_resumed",
+  "health_changed",
+  "violation_detected",
+  "evaluation_started",
+  "execution_started",
+  "execution_completed",
+  "market_event_applied",
+  "objective_restored",
+  "capital_provisioned",
+  "capital_cleared",
+  "capital_synced"
+];
+function isTimelineEventType(value) {
+  return TIMELINE_EVENT_TYPES.includes(value);
+}
+
+// src/types/execution.ts
+function isVaultSettlement(receipt) {
+  return receipt.settlement === "vault";
+}
+
+// src/adapters/logging-adapter.ts
+var silentLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+function createConsoleLogger(prefix = "aureon-sdk") {
+  const write = (level, message, context) => {
+    const line = `[${prefix}] ${message}`;
+    if (level === "error") console.error(line, context ?? "");
+    else if (level === "warn") console.warn(line, context ?? "");
+    else console.log(line, context ?? "");
+  };
+  return {
+    debug: (m, c) => write("debug", m, c),
+    info: (m, c) => write("info", m, c),
+    warn: (m, c) => write("warn", m, c),
+    error: (m, c) => write("error", m, c)
+  };
+}
+
+export { API_KEY_HEADER, AureonClient, AureonConflictError, AureonError, AureonNetworkError, AureonNotFoundError, AureonTimeoutError, AureonValidationError, DEFAULT_API_BASE_URL, DEFAULT_TIMEOUT_MS, ENDPOINTS, LOCAL_API_BASE_URL, OBJECTIVE_KINDS, OBJECTIVE_PRIORITIES, PRODUCT_NAME, PRODUCT_TAGLINE, SDK_NAME, SDK_VERSION, TIMELINE_EVENT_TYPES, assertBaseUrl, buildPolicySummary, createAureonClient, createConsoleLogger, createLocalAureonClient, createSessionTokenProvider, errorFromHttpStatus, formatIsoTime, formatSignedPercent, formatUsd, formatWeight, healthTone, isAureonError, isHealthState, isObjectiveKind, isObjectivePriority, isTimelineEventType, isVaultSettlement, joinUrl, normalizeCreateObjectiveInput, normalizeUpdateObjectiveInput, pickWorstHealth, requestJson, resolveFetch, silentLogger, withQuery };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map