@smplkit/sdk 1.8.4 → 1.9.1

package/dist/index.cjs

@@ -16621,11 +16621,20 @@ var require_pino = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AccountSettings: () => AccountSettings,
+  AccountSettingsClient: () => AccountSettingsClient,
   BooleanFlag: () => BooleanFlag,
   Config: () => Config,
   ConfigClient: () => ConfigClient,
   ConfigManagement: () => ConfigManagement,
   Context: () => Context,
+  ContextEntity: () => ContextEntity,
+  ContextType: () => ContextType,
+  ContextTypesClient: () => ContextTypesClient,
+  ContextsClient: () => ContextsClient,
+  Environment: () => Environment,
+  EnvironmentClassification: () => EnvironmentClassification,
+  EnvironmentsClient: () => EnvironmentsClient,
   Flag: () => Flag,
   FlagChangeEvent: () => FlagChangeEvent,
   FlagStats: () => FlagStats,
@@ -16636,8 +16645,10 @@ __export(index_exports, {
   LogGroup: () => LogGroup,
   LogLevel: () => LogLevel,
   Logger: () => Logger,
+  LoggerSource: () => LoggerSource,
   LoggingClient: () => LoggingClient,
   LoggingManagement: () => LoggingManagement,
+  ManagementClient: () => ManagementClient,
   NumberFlag: () => NumberFlag,
   PinoAdapter: () => PinoAdapter,
   Rule: () => Rule,
@@ -16655,7 +16666,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
-var import_openapi_fetch4 = __toESM(require("openapi-fetch"), 1);
+var import_openapi_fetch5 = __toESM(require("openapi-fetch"), 1);
 
 // src/config/client.ts
 var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
@@ -17887,7 +17898,7 @@ var FlagsClient = class {
   /** Management API — CRUD operations on Flag models. */
   management;
   /** @internal */
-  constructor(apiKey, ensureWs, timeout, flagsBaseUrl, appBaseUrl) {
+  constructor(apiKey, ensureWs, timeout, flagsBaseUrl, appBaseUrl, contextBuffer) {
     this._apiKey = apiKey;
     this._ensureWs = ensureWs;
     const resolvedBaseUrl = flagsBaseUrl ?? FLAGS_BASE_URL;
@@ -17924,6 +17935,9 @@ var FlagsClient = class {
       },
       fetch: fetchWithTimeout
     });
+    if (contextBuffer !== void 0) {
+      this._contextBuffer = contextBuffer;
+    }
     this.management = new FlagsManagement(this);
   }
   // ------------------------------------------------------------------
@@ -18298,25 +18312,6 @@ var FlagsClient = class {
     }
   }
   // ------------------------------------------------------------------
-  // Runtime: context registration
-  // ------------------------------------------------------------------
-  /**
-   * Register context(s) with the server.
-   *
-   * Accepts a single Context or an array. Works before `initialize()` is called.
-   */
-  register(context) {
-    if (Array.isArray(context)) {
-      this._contextBuffer.observe(context);
-    } else {
-      this._contextBuffer.observe([context]);
-    }
-  }
-  /** Flush pending context registrations to the server. */
-  async flushContexts() {
-    await this._flushContexts();
-  }
-  // ------------------------------------------------------------------
   // Runtime: Tier 1 evaluate
   // ------------------------------------------------------------------
   /**
@@ -18885,6 +18880,16 @@ var LoggingManagement = class {
   async deleteGroup(id) {
     return this._client._mgDeleteGroup(id);
   }
+  /**
+   * Bulk-register explicit logger sources with the logging service.
+   *
+   * Unlike `start()`, which auto-discovers loggers from the current
+   * process, this method accepts explicit `service` and `environment`
+   * overrides — useful for sample-data seeding and test fixtures.
+   */
+  async registerSources(sources) {
+    return this._client._mgRegisterSources(sources);
+  }
 };
 var LoggingClient = class {
   /** @internal */
@@ -19063,6 +19068,26 @@ var LoggingClient = class {
     return data.data.map((r) => this._groupToModel(r));
   }
   /** @internal */
+  async _mgRegisterSources(sources) {
+    if (sources.length === 0) return;
+    const loggers = sources.map((src) => ({
+      id: src.name,
+      level: src.level ?? void 0,
+      resolved_level: src.resolvedLevel,
+      service: src.service,
+      environment: src.environment
+    }));
+    try {
+      const result = await this._http.POST("/api/v1/loggers/bulk", {
+        body: { loggers }
+      });
+      if (result.error !== void 0)
+        await checkError3(result.response, "Failed to register sources");
+    } catch (err) {
+      wrapFetchError3(err);
+    }
+  }
+  /** @internal */
   async _mgDeleteGroup(id) {
     const group = await this.management.getGroup(id);
     try {
@@ -19590,10 +19615,11 @@ var LoggingClient = class {
   // ------------------------------------------------------------------
   _loggerToModel(resource) {
     const attrs = resource.attributes;
+    const rawLevel = attrs.level ?? null;
     return new Logger(this, {
       id: resource.id ?? null,
       name: attrs.name,
-      level: attrs.level ?? null,
+      level: rawLevel,
       group: attrs.group ?? null,
       managed: attrs.managed ?? false,
       sources: [],
@@ -19604,11 +19630,12 @@ var LoggingClient = class {
   }
   _groupToModel(resource) {
     const attrs = resource.attributes;
+    const rawLevel = attrs.level ?? null;
     return new LogGroup(this, {
       id: resource.id ?? null,
       key: attrs.key ?? null,
       name: attrs.name,
-      level: attrs.level ?? null,
+      level: rawLevel,
       group: attrs.parent_id ?? null,
       environments: attrs.environments ?? {},
       createdAt: attrs.created_at ?? null,
@@ -19617,6 +19644,664 @@ var LoggingClient = class {
   }
 };
 
+// src/management/client.ts
+var import_openapi_fetch4 = __toESM(require("openapi-fetch"), 1);
+
+// src/management/types.ts
+var EnvironmentClassification = /* @__PURE__ */ ((EnvironmentClassification2) => {
+  EnvironmentClassification2["STANDARD"] = "STANDARD";
+  EnvironmentClassification2["AD_HOC"] = "AD_HOC";
+  return EnvironmentClassification2;
+})(EnvironmentClassification || {});
+
+// src/management/models.ts
+var Environment = class {
+  /** Unique slug identifier (e.g. `"production"`). */
+  id;
+  /** Human-readable display name. */
+  name;
+  /** Hex color code, or null. */
+  color;
+  /** Whether this is a STANDARD or AD_HOC environment. */
+  classification;
+  /** When the environment was created. */
+  createdAt;
+  /** When the environment was last updated. */
+  updatedAt;
+  /** @internal */
+  _client;
+  /** @internal */
+  constructor(client, fields) {
+    this._client = client;
+    this.id = fields.id;
+    this.name = fields.name;
+    this.color = fields.color;
+    this.classification = fields.classification;
+    this.createdAt = fields.createdAt;
+    this.updatedAt = fields.updatedAt;
+  }
+  /** Persist this environment to the server (creates if new, updates if existing). */
+  async save() {
+    if (this._client === null) {
+      throw new Error("Environment was constructed without a client; cannot save");
+    }
+    if (this.createdAt === null) {
+      const saved = await this._client._create(this);
+      this._apply(saved);
+    } else {
+      const saved = await this._client._update(this);
+      this._apply(saved);
+    }
+  }
+  /** @internal */
+  _apply(other) {
+    this.id = other.id;
+    this.name = other.name;
+    this.color = other.color;
+    this.classification = other.classification;
+    this.createdAt = other.createdAt;
+    this.updatedAt = other.updatedAt;
+  }
+  toString() {
+    return `Environment(id=${this.id}, name=${this.name}, classification=${this.classification})`;
+  }
+};
+var ContextType = class {
+  /** Unique slug identifier (e.g. `"user"`). */
+  id;
+  /** Human-readable display name. */
+  name;
+  /** Known attribute keys with metadata objects. */
+  attributes;
+  /** When the context type was created. */
+  createdAt;
+  /** When the context type was last updated. */
+  updatedAt;
+  /** @internal */
+  _client;
+  /** @internal */
+  constructor(client, fields) {
+    this._client = client;
+    this.id = fields.id;
+    this.name = fields.name;
+    this.attributes = { ...fields.attributes };
+    this.createdAt = fields.createdAt;
+    this.updatedAt = fields.updatedAt;
+  }
+  /** Add a known-attribute slot. Local; call `save()` to persist. */
+  addAttribute(name, metadata = {}) {
+    this.attributes = { ...this.attributes, [name]: metadata };
+  }
+  /** Remove a known-attribute slot. Local; call `save()` to persist. */
+  removeAttribute(name) {
+    const attrs = { ...this.attributes };
+    delete attrs[name];
+    this.attributes = attrs;
+  }
+  /** Replace a known-attribute slot's metadata. Local; call `save()` to persist. */
+  updateAttribute(name, metadata) {
+    this.attributes = { ...this.attributes, [name]: metadata };
+  }
+  /** Persist this context type to the server (creates if new, updates if existing). */
+  async save() {
+    if (this._client === null) {
+      throw new Error("ContextType was constructed without a client; cannot save");
+    }
+    if (this.createdAt === null) {
+      const saved = await this._client._create(this);
+      this._apply(saved);
+    } else {
+      const saved = await this._client._update(this);
+      this._apply(saved);
+    }
+  }
+  /** @internal */
+  _apply(other) {
+    this.id = other.id;
+    this.name = other.name;
+    this.attributes = { ...other.attributes };
+    this.createdAt = other.createdAt;
+    this.updatedAt = other.updatedAt;
+  }
+  toString() {
+    return `ContextType(id=${this.id}, name=${this.name})`;
+  }
+};
+var ContextEntity = class {
+  /** Context type key (e.g. `"user"`). */
+  type;
+  /** Entity key (e.g. `"user-123"`). */
+  key;
+  /** Human-readable display name, or null. */
+  name;
+  /** Observed attributes. */
+  attributes;
+  /** When the context was created. */
+  createdAt;
+  /** When the context was last updated. */
+  updatedAt;
+  /** @internal */
+  constructor(fields) {
+    this.type = fields.type;
+    this.key = fields.key;
+    this.name = fields.name;
+    this.attributes = { ...fields.attributes };
+    this.createdAt = fields.createdAt;
+    this.updatedAt = fields.updatedAt;
+  }
+  /** Composite `"type:key"` identifier. */
+  get id() {
+    return `${this.type}:${this.key}`;
+  }
+  toString() {
+    return `ContextEntity(type=${this.type}, key=${this.key})`;
+  }
+};
+var AccountSettings = class {
+  /** @internal */
+  _data;
+  /** @internal */
+  _client;
+  /** @internal */
+  constructor(client, data) {
+    this._client = client;
+    this._data = { ...data };
+  }
+  /** The full settings dict. Direct mutations are reflected in `save()`. */
+  get raw() {
+    return this._data;
+  }
+  set raw(value) {
+    this._data = { ...value };
+  }
+  /** Canonical ordering of STANDARD environments. Empty array if unset. */
+  get environmentOrder() {
+    const val = this._data["environment_order"];
+    return Array.isArray(val) ? [...val] : [];
+  }
+  set environmentOrder(value) {
+    this._data["environment_order"] = [...value];
+  }
+  /** Persist the settings to the server. */
+  async save() {
+    if (this._client === null) {
+      throw new Error("AccountSettings was constructed without a client; cannot save");
+    }
+    const saved = await this._client._save(this._data);
+    this._apply(saved);
+  }
+  /** @internal */
+  _apply(other) {
+    this._data = { ...other._data };
+  }
+  /** @internal — expose raw data for _save(). */
+  get _rawData() {
+    return this._data;
+  }
+  toString() {
+    return `AccountSettings(${JSON.stringify(this._data)})`;
+  }
+};
+
+// src/management/client.ts
+function splitContextId(idOrType, key) {
+  if (key === void 0) {
+    if (!idOrType.includes(":")) {
+      throw new Error(
+        `context id must be 'type:key' (got ${JSON.stringify(idOrType)}); alternatively pass type and key as separate args`
+      );
+    }
+    const colonIdx = idOrType.indexOf(":");
+    return [idOrType.slice(0, colonIdx), idOrType.slice(colonIdx + 1)];
+  }
+  return [idOrType, key];
+}
+async function checkError4(response, _context) {
+  const body = await response.text().catch(() => "");
+  throwForStatus(response.status, body);
+}
+function wrapFetchError4(err) {
+  if (err instanceof SmplError) {
+    throw err;
+  }
+  if (err instanceof TypeError) {
+    throw new SmplConnectionError(`Network error: ${err.message}`);
+  }
+  throw new SmplConnectionError(
+    `Request failed: ${err instanceof Error ? err.message : String(err)}`
+  );
+}
+function envFromResource(resource, client) {
+  const attrs = resource.attributes ?? {};
+  return new Environment(client, {
+    id: resource.id ?? null,
+    name: attrs.name ?? "",
+    color: attrs.color ?? null,
+    classification: attrs.classification === "AD_HOC" ? "AD_HOC" /* AD_HOC */ : "STANDARD" /* STANDARD */,
+    createdAt: attrs.created_at ?? null,
+    updatedAt: attrs.updated_at ?? null
+  });
+}
+function ctFromResource(resource, client) {
+  const attrs = resource.attributes ?? {};
+  const rawMeta = attrs.attributes;
+  const attributeMetadata = {};
+  if (rawMeta && typeof rawMeta === "object") {
+    for (const [k, v] of Object.entries(rawMeta)) {
+      attributeMetadata[k] = typeof v === "object" && v !== null ? v : {};
+    }
+  }
+  return new ContextType(client, {
+    id: resource.id ?? null,
+    name: attrs.name ?? "",
+    attributes: attributeMetadata,
+    createdAt: attrs.created_at ?? null,
+    updatedAt: attrs.updated_at ?? null
+  });
+}
+function ctxEntityFromResource(resource) {
+  const compositeId = resource.id ?? "";
+  const colonIdx = compositeId.indexOf(":");
+  const ctxType = colonIdx >= 0 ? compositeId.slice(0, colonIdx) : compositeId;
+  const ctxKey = colonIdx >= 0 ? compositeId.slice(colonIdx + 1) : "";
+  const attrs = resource.attributes ?? {};
+  const rawAttrs = attrs.attributes;
+  const attrDict = rawAttrs && typeof rawAttrs === "object" ? { ...rawAttrs } : {};
+  return new ContextEntity({
+    type: ctxType,
+    key: ctxKey,
+    name: attrs.name ?? null,
+    attributes: attrDict,
+    createdAt: attrs.created_at ?? null,
+    updatedAt: attrs.updated_at ?? null
+  });
+}
+var EnvironmentsClient = class {
+  /** @internal */
+  constructor(_http) {
+    this._http = _http;
+  }
+  /**
+   * Return an unsaved `Environment`. Call `.save()` to persist.
+   */
+  new(id, options) {
+    return new Environment(this, {
+      id,
+      name: options.name,
+      color: options.color ?? null,
+      classification: options.classification ?? "STANDARD" /* STANDARD */,
+      createdAt: null,
+      updatedAt: null
+    });
+  }
+  /** List all environments. */
+  async list() {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/environments", {});
+      if (!result.response.ok) await checkError4(result.response, "Failed to list environments");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    const items = data?.data ?? [];
+    return items.map((r) => envFromResource(r, this));
+  }
+  /** Fetch an environment by id. */
+  async get(id) {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/environments/{id}", {
+        params: { path: { id } }
+      });
+      if (!result.response.ok) await checkError4(result.response, `Environment '${id}' not found`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    if (!data?.data) throw new SmplNotFoundError(`Environment with id '${id}' not found`);
+    return envFromResource(data.data, this);
+  }
+  /** Delete an environment by id. */
+  async delete(id) {
+    try {
+      const result = await this._http.DELETE("/api/v1/environments/{id}", {
+        params: { path: { id } }
+      });
+      if (!result.response.ok && result.response.status !== 204)
+        await checkError4(result.response, `Failed to delete environment '${id}'`);
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+  }
+  /** @internal — called by Environment.save() for new resources. */
+  async _create(env) {
+    const body = {
+      data: {
+        id: env.id,
+        type: "environment",
+        attributes: {
+          name: env.name,
+          color: env.color,
+          classification: env.classification
+        }
+      }
+    };
+    let data;
+    try {
+      const result = await this._http.POST("/api/v1/environments", { body });
+      if (!result.response.ok) await checkError4(result.response, "Failed to create environment");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    if (!data?.data) throw new SmplValidationError("Failed to create environment");
+    return envFromResource(data.data, this);
+  }
+  /** @internal — called by Environment.save() for existing resources. */
+  async _update(env) {
+    if (!env.id) throw new Error("Cannot update an Environment with no id");
+    const body = {
+      data: {
+        id: env.id,
+        type: "environment",
+        attributes: {
+          name: env.name,
+          color: env.color,
+          classification: env.classification
+        }
+      }
+    };
+    let data;
+    try {
+      const result = await this._http.PUT("/api/v1/environments/{id}", {
+        params: { path: { id: env.id } },
+        body
+      });
+      if (!result.response.ok)
+        await checkError4(result.response, `Failed to update environment ${env.id}`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    if (!data?.data) throw new SmplValidationError(`Failed to update environment ${env.id}`);
+    return envFromResource(data.data, this);
+  }
+};
+var ContextTypesClient = class {
+  /** @internal */
+  constructor(_http) {
+    this._http = _http;
+  }
+  /**
+   * Return an unsaved `ContextType`. Call `.save()` to persist.
+   */
+  new(id, options = {}) {
+    return new ContextType(this, {
+      id,
+      name: options.name ?? id,
+      attributes: options.attributes ?? {},
+      createdAt: null,
+      updatedAt: null
+    });
+  }
+  /** List all context types. */
+  async list() {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/context_types", {});
+      if (!result.response.ok) await checkError4(result.response, "Failed to list context types");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    const items = data?.data ?? [];
+    return items.map((r) => ctFromResource(r, this));
+  }
+  /** Fetch a context type by id. */
+  async get(id) {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/context_types/{id}", {
+        params: { path: { id } }
+      });
+      if (!result.response.ok) await checkError4(result.response, `ContextType '${id}' not found`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    if (!data?.data) throw new SmplNotFoundError(`ContextType with id '${id}' not found`);
+    return ctFromResource(data.data, this);
+  }
+  /** Delete a context type by id. */
+  async delete(id) {
+    try {
+      const result = await this._http.DELETE("/api/v1/context_types/{id}", {
+        params: { path: { id } }
+      });
+      if (!result.response.ok && result.response.status !== 204)
+        await checkError4(result.response, `Failed to delete context type '${id}'`);
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+  }
+  /** @internal — called by ContextType.save() for new resources. */
+  async _create(ct) {
+    const body = {
+      data: {
+        id: ct.id,
+        type: "context_type",
+        attributes: {
+          name: ct.name,
+          attributes: ct.attributes
+        }
+      }
+    };
+    let data;
+    try {
+      const result = await this._http.POST("/api/v1/context_types", { body });
+      if (!result.response.ok) await checkError4(result.response, "Failed to create context type");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    if (!data?.data) throw new SmplValidationError("Failed to create context type");
+    return ctFromResource(data.data, this);
+  }
+  /** @internal — called by ContextType.save() for existing resources. */
+  async _update(ct) {
+    if (!ct.id) throw new Error("Cannot update a ContextType with no id");
+    const body = {
+      data: {
+        id: ct.id,
+        type: "context_type",
+        attributes: {
+          name: ct.name,
+          attributes: ct.attributes
+        }
+      }
+    };
+    let data;
+    try {
+      const result = await this._http.PUT("/api/v1/context_types/{id}", {
+        params: { path: { id: ct.id } },
+        body
+      });
+      if (!result.response.ok)
+        await checkError4(result.response, `Failed to update context type ${ct.id}`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    if (!data?.data) throw new SmplValidationError(`Failed to update context type ${ct.id}`);
+    return ctFromResource(data.data, this);
+  }
+};
+var ContextsClient = class {
+  /** @internal */
+  constructor(_http, _buffer) {
+    this._http = _http;
+    this._buffer = _buffer;
+  }
+  /**
+   * Buffer context(s) for registration; optionally flush immediately.
+   *
+   * When `flush` is false (default), contexts are queued for the SDK's
+   * background flush — right for high-frequency observation from a live
+   * request handler. When `flush` is true the call awaits the round-trip
+   * — right for IaC scripts.
+   */
+  async register(items, options = {}) {
+    const batch = Array.isArray(items) ? items : [items];
+    this._buffer.observe(batch);
+    if (options.flush) {
+      await this.flush();
+    }
+  }
+  /** Send any pending context observations to the server. */
+  async flush() {
+    const batch = this._buffer.drain();
+    if (batch.length === 0) return;
+    try {
+      const result = await this._http.POST("/api/v1/contexts/bulk", {
+        body: {
+          contexts: batch.map((ctx) => ({
+            type: ctx.type,
+            key: ctx.key,
+            attributes: ctx.attributes
+          }))
+        }
+      });
+      if (!result.response.ok) await checkError4(result.response, "Failed to flush contexts");
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+  }
+  /** List all contexts of a given type. */
+  async list(type) {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/contexts", {
+        params: { query: { "filter[context_type]": type } }
+      });
+      if (!result.response.ok) await checkError4(result.response, "Failed to list contexts");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    const items = data?.data ?? [];
+    return items.map(ctxEntityFromResource);
+  }
+  /** Fetch a context by composite id (`"type:key"`) or by separate type and key. */
+  async get(idOrType, key) {
+    const [ctxType, ctxKey] = splitContextId(idOrType, key);
+    const composite = `${ctxType}:${ctxKey}`;
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/contexts/{id}", {
+        params: { path: { id: composite } }
+      });
+      if (!result.response.ok)
+        await checkError4(result.response, `Context '${composite}' not found`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+    if (!data?.data) throw new SmplNotFoundError(`Context with id '${composite}' not found`);
+    return ctxEntityFromResource(data.data);
+  }
+  /** Delete a context by composite id (`"type:key"`) or by separate type and key. */
+  async delete(idOrType, key) {
+    const [ctxType, ctxKey] = splitContextId(idOrType, key);
+    const composite = `${ctxType}:${ctxKey}`;
+    try {
+      const result = await this._http.DELETE("/api/v1/contexts/{id}", {
+        params: { path: { id: composite } }
+      });
+      if (!result.response.ok && result.response.status !== 204)
+        await checkError4(result.response, `Failed to delete context '${composite}'`);
+    } catch (err) {
+      wrapFetchError4(err);
+    }
+  }
+};
+var AccountSettingsClient = class {
+  /** @internal */
+  constructor(_appBaseUrl, apiKey) {
+    this._appBaseUrl = _appBaseUrl;
+    this._headers = {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+  }
+  _headers;
+  /** Fetch the current account settings. */
+  async get() {
+    const url = `${this._appBaseUrl}/api/v1/accounts/current/settings`;
+    let resp;
+    try {
+      resp = await fetch(url, { headers: this._headers });
+    } catch (err) {
+      throw new SmplConnectionError(
+        `Network error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throwForStatus(resp.status, body);
+    }
+    const data = await resp.json();
+    return new AccountSettings(this, data ?? {});
+  }
+  /** @internal — called by AccountSettings.save(). */
+  async _save(data) {
+    const url = `${this._appBaseUrl}/api/v1/accounts/current/settings`;
+    let resp;
+    try {
+      resp = await fetch(url, {
+        method: "PUT",
+        headers: this._headers,
+        body: JSON.stringify(data)
+      });
+    } catch (err) {
+      throw new SmplConnectionError(
+        `Network error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throwForStatus(resp.status, body);
+    }
+    const saved = await resp.json();
+    return new AccountSettings(this, saved ?? {});
+  }
+};
+var ManagementClient = class {
+  /** CRUD for environments. */
+  environments;
+  /** Registration, list, get, and delete for context instances. */
+  contexts;
+  /** CRUD for context types (entity schemas). */
+  context_types;
+  /** Get/save for account-level settings. */
+  account_settings;
+  /** @internal */
+  constructor(options) {
+    const http = (0, import_openapi_fetch4.default)({
+      baseUrl: options.appBaseUrl,
+      headers: {
+        Authorization: `Bearer ${options.apiKey}`,
+        Accept: "application/json"
+      }
+    });
+    this.environments = new EnvironmentsClient(http);
+    this.contexts = new ContextsClient(http, options.buffer);
+    this.context_types = new ContextTypesClient(http);
+    this.account_settings = new AccountSettingsClient(options.appBaseUrl, options.apiKey);
+  }
+};
+
 // src/ws.ts
 var import_ws = __toESM(require("ws"), 1);
 var BACKOFF_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 32e3, 6e4];
@@ -20054,6 +20739,8 @@ var SmplClient = class {
   flags;
   /** Client for logging management and runtime. */
   logging;
+  /** Client for app-plane management (environments, contexts, context types, account settings). */
+  management;
   _wsManager = null;
   _apiKey;
   /** @internal */
@@ -20084,7 +20771,7 @@ var SmplClient = class {
       "lifecycle",
       `SmplClient created (api_key=${maskedKey}, environment=${cfg.environment}, service=${cfg.service})`
     );
-    this._appHttp = (0, import_openapi_fetch4.default)({
+    this._appHttp = (0, import_openapi_fetch5.default)({
       baseUrl: appBaseUrl,
       headers: {
         Authorization: `Bearer ${cfg.apiKey}`,
@@ -20099,13 +20786,15 @@ var SmplClient = class {
         appBaseUrl
       });
     }
+    const sharedContextBuffer = new ContextRegistrationBuffer();
     this.config = new ConfigClient(cfg.apiKey, this._timeout, configBaseUrl);
     this.flags = new FlagsClient(
       cfg.apiKey,
       () => this._ensureWs(),
       this._timeout,
       flagsBaseUrl,
-      appBaseUrl
+      appBaseUrl,
+      sharedContextBuffer
     );
     this.logging = new LoggingClient(
       cfg.apiKey,
@@ -20113,6 +20802,11 @@ var SmplClient = class {
       this._timeout,
       loggingBaseUrl
     );
+    this.management = new ManagementClient({
+      appBaseUrl,
+      apiKey: cfg.apiKey,
+      buffer: sharedContextBuffer
+    });
     this.config._getSharedWs = () => this._ensureWs();
     this.flags._parent = this;
     this.config._parent = this;
@@ -20238,6 +20932,25 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2["SILENT"] = "SILENT";
   return LogLevel2;
 })(LogLevel || {});
+var LoggerSource = class {
+  /** Logger name (e.g. `"sqlalchemy.engine"`). */
+  name;
+  /** Service name this source belongs to. */
+  service;
+  /** Environment name this source belongs to. */
+  environment;
+  /** Effective log level for this source. */
+  resolvedLevel;
+  /** Explicit (configured) log level, if different from `resolvedLevel`. */
+  level;
+  constructor(name, options) {
+    this.name = name;
+    this.service = options.service;
+    this.environment = options.environment;
+    this.resolvedLevel = options.resolved_level;
+    this.level = options.level ?? null;
+  }
+};
 
 // src/logging/adapters/winston.ts
 var SMPLKIT_TO_WINSTON = {
@@ -20464,11 +21177,20 @@ var PinoAdapter = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AccountSettings,
+  AccountSettingsClient,
   BooleanFlag,
   Config,
   ConfigClient,
   ConfigManagement,
   Context,
+  ContextEntity,
+  ContextType,
+  ContextTypesClient,
+  ContextsClient,
+  Environment,
+  EnvironmentClassification,
+  EnvironmentsClient,
   Flag,
   FlagChangeEvent,
   FlagStats,
@@ -20479,8 +21201,10 @@ var PinoAdapter = class {
   LogGroup,
   LogLevel,
   Logger,
+  LoggerSource,
   LoggingClient,
   LoggingManagement,
+  ManagementClient,
   NumberFlag,
   PinoAdapter,
   Rule,