@smplkit/sdk 1.0.1 → 1.1.0

package/dist/index.cjs

@@ -1,8 +1,13 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,12 +20,349 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/config/resolve.ts
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (key in result && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key]) && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = deepMerge(
+        result[key],
+        value
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function resolveChain(chain, environment) {
+  let accumulated = {};
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const config = chain[i];
+    const baseValues = config.values ?? {};
+    const envEntry = (config.environments ?? {})[environment];
+    const envValues = envEntry !== null && envEntry !== void 0 && typeof envEntry === "object" && !Array.isArray(envEntry) ? envEntry.values ?? {} : {};
+    const configResolved = deepMerge(baseValues, envValues);
+    accumulated = deepMerge(accumulated, configResolved);
+  }
+  return accumulated;
+}
+var init_resolve = __esm({
+  "src/config/resolve.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  ConfigRuntime: () => ConfigRuntime
+});
+var import_ws, BACKOFF_MS, ConfigRuntime;
+var init_runtime = __esm({
+  "src/config/runtime.ts"() {
+    "use strict";
+    import_ws = __toESM(require("ws"), 1);
+    init_resolve();
+    BACKOFF_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 32e3, 6e4];
+    ConfigRuntime = class {
+      _cache;
+      _chain;
+      _fetchCount;
+      _lastFetchAt;
+      _closed = false;
+      _wsStatus = "disconnected";
+      _ws = null;
+      _reconnectTimer = null;
+      _backoffIndex = 0;
+      _listeners = [];
+      _configId;
+      _environment;
+      _apiKey;
+      _baseUrl;
+      _fetchChain;
+      /** @internal */
+      constructor(options) {
+        this._configId = options.configId;
+        this._environment = options.environment;
+        this._apiKey = options.apiKey;
+        this._baseUrl = options.baseUrl;
+        this._fetchChain = options.fetchChain;
+        this._chain = options.chain;
+        this._cache = resolveChain(options.chain, options.environment);
+        this._fetchCount = options.chain.length;
+        this._lastFetchAt = (/* @__PURE__ */ new Date()).toISOString();
+        this._connectWebSocket();
+      }
+      // ---- Value access (synchronous, local cache) ----
+      /**
+       * Return the resolved value for `key`, or `defaultValue` if absent.
+       *
+       * @param key - The config key to look up.
+       * @param defaultValue - Returned when the key is not present (default: null).
+       */
+      get(key, defaultValue = null) {
+        return key in this._cache ? this._cache[key] : defaultValue;
+      }
+      /**
+       * Return the value as a string, or `defaultValue` if absent or not a string.
+       */
+      getString(key, defaultValue = null) {
+        const value = this._cache[key];
+        return typeof value === "string" ? value : defaultValue;
+      }
+      /**
+       * Return the value as a number, or `defaultValue` if absent or not a number.
+       */
+      getNumber(key, defaultValue = null) {
+        const value = this._cache[key];
+        return typeof value === "number" ? value : defaultValue;
+      }
+      /**
+       * Return the value as a boolean, or `defaultValue` if absent or not a boolean.
+       */
+      getBool(key, defaultValue = null) {
+        const value = this._cache[key];
+        return typeof value === "boolean" ? value : defaultValue;
+      }
+      /**
+       * Return whether `key` is present in the resolved configuration.
+       */
+      exists(key) {
+        return key in this._cache;
+      }
+      /**
+       * Return a shallow copy of the full resolved configuration.
+       */
+      getAll() {
+        return { ...this._cache };
+      }
+      // ---- Change listeners ----
+      /**
+       * Register a listener that fires when a config value changes.
+       *
+       * @param callback - Called with a {@link ConfigChangeEvent} on each change.
+       * @param options.key - If provided, the listener fires only for this key.
+       *   If omitted, the listener fires for all changes.
+       */
+      onChange(callback, options) {
+        this._listeners.push({
+          callback,
+          key: options?.key ?? null
+        });
+      }
+      // ---- Diagnostics ----
+      /**
+       * Return diagnostic statistics for this runtime.
+       */
+      stats() {
+        return {
+          fetchCount: this._fetchCount,
+          lastFetchAt: this._lastFetchAt
+        };
+      }
+      /**
+       * Return the current WebSocket connection status.
+       */
+      connectionStatus() {
+        return this._wsStatus;
+      }
+      // ---- Lifecycle ----
+      /**
+       * Force a manual refresh of the cached configuration.
+       *
+       * Re-fetches the full config chain via HTTP, re-resolves values, updates
+       * the local cache, and fires listeners for any detected changes.
+       *
+       * @throws {Error} If no `fetchChain` function was provided on construction.
+       */
+      async refresh() {
+        if (!this._fetchChain) {
+          throw new Error("No fetchChain function provided; cannot refresh.");
+        }
+        const newChain = await this._fetchChain();
+        const oldCache = this._cache;
+        this._chain = newChain;
+        this._cache = resolveChain(newChain, this._environment);
+        this._fetchCount += newChain.length;
+        this._lastFetchAt = (/* @__PURE__ */ new Date()).toISOString();
+        this._diffAndFire(oldCache, this._cache, "manual");
+      }
+      /**
+       * Close the runtime connection.
+       *
+       * Shuts down the WebSocket and cancels any pending reconnect timer.
+       * Safe to call multiple times.
+       */
+      async close() {
+        this._closed = true;
+        this._wsStatus = "disconnected";
+        if (this._reconnectTimer !== null) {
+          clearTimeout(this._reconnectTimer);
+          this._reconnectTimer = null;
+        }
+        if (this._ws !== null) {
+          this._ws.close();
+          this._ws = null;
+        }
+      }
+      /**
+       * Async dispose support for `await using` (TypeScript 5.2+).
+       */
+      async [Symbol.asyncDispose]() {
+        await this.close();
+      }
+      // ---- WebSocket internals ----
+      _buildWsUrl() {
+        let url = this._baseUrl;
+        if (url.startsWith("https://")) {
+          url = "wss://" + url.slice("https://".length);
+        } else if (url.startsWith("http://")) {
+          url = "ws://" + url.slice("http://".length);
+        } else {
+          url = "wss://" + url;
+        }
+        url = url.replace(/\/$/, "");
+        return `${url}/api/ws/v1/configs?api_key=${this._apiKey}`;
+      }
+      _connectWebSocket() {
+        if (this._closed) return;
+        this._wsStatus = "connecting";
+        const wsUrl = this._buildWsUrl();
+        try {
+          const ws = new import_ws.default(wsUrl);
+          this._ws = ws;
+          ws.on("open", () => {
+            if (this._closed) {
+              ws.close();
+              return;
+            }
+            this._backoffIndex = 0;
+            this._wsStatus = "connected";
+            ws.send(
+              JSON.stringify({
+                type: "subscribe",
+                config_id: this._configId,
+                environment: this._environment
+              })
+            );
+          });
+          ws.on("message", (data) => {
+            try {
+              const msg = JSON.parse(String(data));
+              this._handleMessage(msg);
+            } catch {
+            }
+          });
+          ws.on("close", () => {
+            if (!this._closed) {
+              this._wsStatus = "disconnected";
+              this._scheduleReconnect();
+            }
+          });
+          ws.on("error", () => {
+          });
+        } catch {
+          if (!this._closed) {
+            this._scheduleReconnect();
+          }
+        }
+      }
+      _scheduleReconnect() {
+        if (this._closed) return;
+        const delay = BACKOFF_MS[Math.min(this._backoffIndex, BACKOFF_MS.length - 1)];
+        this._backoffIndex++;
+        this._wsStatus = "connecting";
+        this._reconnectTimer = setTimeout(() => {
+          this._reconnectTimer = null;
+          if (this._fetchChain) {
+            this._fetchChain().then((newChain) => {
+              const oldCache = this._cache;
+              this._chain = newChain;
+              this._cache = resolveChain(newChain, this._environment);
+              this._fetchCount += newChain.length;
+              this._lastFetchAt = (/* @__PURE__ */ new Date()).toISOString();
+              this._diffAndFire(oldCache, this._cache, "manual");
+            }).catch(() => {
+            }).finally(() => {
+              this._connectWebSocket();
+            });
+          } else {
+            this._connectWebSocket();
+          }
+        }, delay);
+      }
+      _handleMessage(msg) {
+        if (msg.type === "config_changed") {
+          this._applyChanges(msg.config_id, msg.changes);
+        } else if (msg.type === "config_deleted") {
+          this._closed = true;
+          void this.close();
+        }
+      }
+      _applyChanges(configId, changes) {
+        const chainEntry = this._chain.find((c) => c.id === configId);
+        if (!chainEntry) return;
+        for (const change of changes) {
+          const { key, new_value } = change;
+          const envEntry = chainEntry.environments[this._environment] !== void 0 && chainEntry.environments[this._environment] !== null ? chainEntry.environments[this._environment] : null;
+          const envValues = envEntry !== null && typeof envEntry === "object" ? envEntry.values ?? {} : null;
+          if (new_value === null || new_value === void 0) {
+            delete chainEntry.values[key];
+            if (envValues) delete envValues[key];
+          } else if (envValues && key in envValues) {
+            envValues[key] = new_value;
+          } else if (key in chainEntry.values) {
+            chainEntry.values[key] = new_value;
+          } else {
+            chainEntry.values[key] = new_value;
+          }
+        }
+        const oldCache = this._cache;
+        this._cache = resolveChain(this._chain, this._environment);
+        this._diffAndFire(oldCache, this._cache, "websocket");
+      }
+      _diffAndFire(oldCache, newCache, source) {
+        const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldCache), ...Object.keys(newCache)]);
+        for (const key of allKeys) {
+          const oldVal = key in oldCache ? oldCache[key] : null;
+          const newVal = key in newCache ? newCache[key] : null;
+          if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+            const event = { key, oldValue: oldVal, newValue: newVal, source };
+            this._fireListeners(event);
+          }
+        }
+      }
+      _fireListeners(event) {
+        for (const listener of this._listeners) {
+          if (listener.key === null || listener.key === event.key) {
+            try {
+              listener.callback(event);
+            } catch {
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Config: () => Config,
   ConfigClient: () => ConfigClient,
+  ConfigRuntime: () => ConfigRuntime,
   SmplConflictError: () => SmplConflictError,
   SmplConnectionError: () => SmplConnectionError,
   SmplError: () => SmplError,
@@ -31,6 +373,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/config/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+
 // src/errors.ts
 var SmplError = class extends Error {
   /** The HTTP status code, if the error originated from an HTTP response. */
@@ -81,277 +426,443 @@ var SmplValidationError = class extends SmplError {
   }
 };
 
-// src/config/client.ts
-var CONFIGS_PATH = "/api/v1/configs";
-var ConfigClient = class {
-  /** @internal */
-  transport;
+// src/config/types.ts
+var Config = class {
+  /** UUID of the config. */
+  id;
+  /** Human-readable key (e.g. `"user_service"`). */
+  key;
+  /** Display name. */
+  name;
+  /** Optional description. */
+  description;
+  /** Parent config UUID, or null if this is a root config. */
+  parent;
+  /** Base key-value pairs. */
+  values;
+  /**
+   * Per-environment overrides.
+   * Stored as `{ env_name: { values: { key: value } } }` to match the
+   * server's format.
+   */
+  environments;
+  /** When the config was created, or null if unavailable. */
+  createdAt;
+  /** When the config was last updated, or null if unavailable. */
+  updatedAt;
+  /**
+   * Internal reference to the parent client.
+   * @internal
+   */
+  _client;
   /** @internal */
-  constructor(transport) {
-    this.transport = transport;
+  constructor(client, fields) {
+    this._client = client;
+    this.id = fields.id;
+    this.key = fields.key;
+    this.name = fields.name;
+    this.description = fields.description;
+    this.parent = fields.parent;
+    this.values = fields.values;
+    this.environments = fields.environments;
+    this.createdAt = fields.createdAt;
+    this.updatedAt = fields.updatedAt;
   }
   /**
-   * Fetch a single config by key or UUID.
+   * Update this config's attributes on the server.
    *
-   * Exactly one of `key` or `id` must be provided.
+   * Builds the request from current attribute values, overriding with any
+   * provided options. Updates local attributes in place on success.
    *
-   * @param options - Lookup options.
-   * @returns The matching config.
-   * @throws {SmplNotFoundError} If no matching config exists.
-   * @throws {Error} If neither or both of `key` and `id` are provided.
+   * @param options.name - New display name.
+   * @param options.description - New description (pass empty string to clear).
+   * @param options.values - New base values (replaces entirely).
+   * @param options.environments - New environments dict (replaces entirely).
    */
-  async get(options) {
-    const { key, id } = options;
-    if (key === void 0 === (id === void 0)) {
-      throw new Error("Exactly one of 'key' or 'id' must be provided.");
-    }
-    if (id !== void 0) {
-      return this.getById(id);
-    }
-    return this.getByKey(key);
+  async update(options) {
+    const updated = await this._client._updateConfig({
+      configId: this.id,
+      name: options.name ?? this.name,
+      key: this.key,
+      description: options.description !== void 0 ? options.description : this.description,
+      parent: this.parent,
+      values: options.values ?? this.values,
+      environments: options.environments ?? this.environments
+    });
+    this.name = updated.name;
+    this.description = updated.description;
+    this.values = updated.values;
+    this.environments = updated.environments;
+    this.updatedAt = updated.updatedAt;
   }
   /**
-   * List all configs for the account.
+   * Replace base or environment-specific values.
+   *
+   * When `environment` is provided, replaces that environment's `values`
+   * sub-dict (other environments are preserved). When omitted, replaces
+   * the base `values`.
    *
-   * @returns An array of config objects.
+   * @param values - The complete set of values to set.
+   * @param environment - Target environment, or omit for base values.
    */
-  async list() {
-    const response = await this.transport.get(CONFIGS_PATH);
-    const resources = response.data;
-    return resources.map((r) => this.resourceToModel(r));
+  async setValues(values, environment) {
+    let newValues;
+    let newEnvs;
+    if (environment === void 0) {
+      newValues = values;
+      newEnvs = this.environments;
+    } else {
+      newValues = this.values;
+      const existingEntry = typeof this.environments[environment] === "object" && this.environments[environment] !== null ? { ...this.environments[environment] } : {};
+      existingEntry.values = values;
+      newEnvs = { ...this.environments, [environment]: existingEntry };
+    }
+    const updated = await this._client._updateConfig({
+      configId: this.id,
+      name: this.name,
+      key: this.key,
+      description: this.description,
+      parent: this.parent,
+      values: newValues,
+      environments: newEnvs
+    });
+    this.values = updated.values;
+    this.environments = updated.environments;
+    this.updatedAt = updated.updatedAt;
   }
   /**
-   * Create a new config.
+   * Set a single key within base or environment-specific values.
    *
-   * @param options - Config creation options.
-   * @returns The created config.
-   * @throws {SmplValidationError} If the server rejects the request.
+   * Merges the key into existing values rather than replacing all values.
+   *
+   * @param key - The config key to set.
+   * @param value - The value to assign.
+   * @param environment - Target environment, or omit for base values.
    */
-  async create(options) {
-    const body = this.buildRequestBody(options);
-    const response = await this.transport.post(CONFIGS_PATH, body);
-    if (!response.data) {
-      throw new SmplValidationError("Failed to create config");
+  async setValue(key, value, environment) {
+    if (environment === void 0) {
+      const merged = { ...this.values, [key]: value };
+      await this.setValues(merged);
+    } else {
+      const envEntry = typeof this.environments[environment] === "object" && this.environments[environment] !== null ? this.environments[environment] : {};
+      const existing = {
+        ...typeof envEntry.values === "object" && envEntry.values !== null ? envEntry.values : {}
+      };
+      existing[key] = value;
+      await this.setValues(existing, environment);
     }
-    return this.resourceToModel(response.data);
   }
   /**
-   * Delete a config by UUID.
+   * Connect to this config for runtime value resolution.
    *
-   * @param configId - The UUID of the config to delete.
-   * @throws {SmplNotFoundError} If the config does not exist.
-   * @throws {SmplConflictError} If the config has children.
+   * Eagerly fetches this config and its full parent chain, resolves values
+   * for the given environment via deep merge, and returns a
+   * {@link ConfigRuntime} with a fully populated local cache.
+   *
+   * A background WebSocket connection is started for real-time updates.
+   * If the WebSocket fails to connect, the runtime operates in cache-only
+   * mode and reconnects automatically.
+   *
+   * Supports both `await` and `await using` (TypeScript 5.2+)::
+   *
+   * ```typescript
+   * // Simple await
+   * const runtime = await config.connect("production");
+   * try { ... } finally { await runtime.close(); }
+   *
+   * // await using (auto-close)
+   * await using runtime = await config.connect("production");
+   * ```
+   *
+   * @param environment - The environment to resolve for (e.g. `"production"`).
+   * @param options.timeout - Milliseconds to wait for the initial fetch.
    */
-  async delete(configId) {
-    await this.transport.delete(`${CONFIGS_PATH}/${configId}`);
-  }
-  /** Fetch a config by UUID. */
-  async getById(configId) {
-    const response = await this.transport.get(`${CONFIGS_PATH}/${configId}`);
-    if (!response.data) {
-      throw new SmplNotFoundError(`Config ${configId} not found`);
-    }
-    return this.resourceToModel(response.data);
-  }
-  /** Fetch a config by key using the list endpoint with a filter. */
-  async getByKey(key) {
-    const response = await this.transport.get(CONFIGS_PATH, { "filter[key]": key });
-    const resources = response.data;
-    if (!resources || resources.length === 0) {
-      throw new SmplNotFoundError(`Config with key '${key}' not found`);
-    }
-    return this.resourceToModel(resources[0]);
+  async connect(environment, options) {
+    const { ConfigRuntime: ConfigRuntime2 } = await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    const timeout = options?.timeout ?? 3e4;
+    const chain = await this._buildChain(timeout);
+    return new ConfigRuntime2({
+      configKey: this.key,
+      configId: this.id,
+      environment,
+      chain,
+      apiKey: this._client._apiKey,
+      baseUrl: this._client._baseUrl,
+      fetchChain: () => this._buildChain(timeout)
+    });
   }
   /**
-   * Convert a JSON:API resource to a Config domain model.
+   * Walk the parent chain and return config data objects, child-to-root.
    * @internal
    */
-  resourceToModel(resource) {
-    const attrs = resource.attributes;
-    return {
-      id: resource.id,
-      key: attrs.key ?? "",
-      name: attrs.name,
-      description: attrs.description ?? null,
-      parent: attrs.parent ?? null,
-      values: attrs.values ?? {},
-      environments: attrs.environments ?? {},
-      createdAt: attrs.created_at ? new Date(attrs.created_at) : null,
-      updatedAt: attrs.updated_at ? new Date(attrs.updated_at) : null
-    };
+  async _buildChain(_timeout) {
+    const chain = [{ id: this.id, values: this.values, environments: this.environments }];
+    let parentId = this.parent;
+    while (parentId !== null) {
+      const parentConfig = await this._client.get({ id: parentId });
+      chain.push({
+        id: parentConfig.id,
+        values: parentConfig.values,
+        environments: parentConfig.environments
+      });
+      parentId = parentConfig.parent;
+    }
+    return chain;
   }
-  /** Build a JSON:API request body for create operations. */
-  buildRequestBody(options) {
-    const attributes = {
-      name: options.name
-    };
-    if (options.key !== void 0) attributes.key = options.key;
-    if (options.description !== void 0) attributes.description = options.description;
-    if (options.parent !== void 0) attributes.parent = options.parent;
-    if (options.values !== void 0) attributes.values = options.values;
-    return {
-      data: {
-        type: "config",
-        attributes
-      }
-    };
+  toString() {
+    return `Config(id=${this.id}, key=${this.key}, name=${this.name})`;
   }
 };
 
-// src/auth.ts
-function buildAuthHeader(apiKey) {
-  return `Bearer ${apiKey}`;
+// src/config/client.ts
+var BASE_URL = "https://config.smplkit.com";
+function resourceToConfig(resource, client) {
+  const attrs = resource.attributes;
+  return new Config(client, {
+    id: resource.id ?? "",
+    key: attrs.key ?? "",
+    name: attrs.name,
+    description: attrs.description ?? null,
+    parent: attrs.parent ?? null,
+    values: attrs.values ?? {},
+    environments: attrs.environments ?? {},
+    createdAt: attrs.created_at ? new Date(attrs.created_at) : null,
+    updatedAt: attrs.updated_at ? new Date(attrs.updated_at) : null
+  });
 }
-
-// src/transport.ts
-var SDK_VERSION = "0.0.0";
-var DEFAULT_TIMEOUT_MS = 3e4;
-var Transport = class {
-  apiKey;
-  baseUrl;
-  timeout;
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
-    this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+async function checkError(response, context) {
+  const body = await response.text().catch(() => "");
+  switch (response.status) {
+    case 404:
+      throw new SmplNotFoundError(body || context, 404, body);
+    case 409:
+      throw new SmplConflictError(body || context, 409, body);
+    case 422:
+      throw new SmplValidationError(body || context, 422, body);
+    default:
+      throw new SmplError(`HTTP ${response.status}: ${body}`, response.status, body);
+  }
+}
+function wrapFetchError(err) {
+  if (err instanceof SmplNotFoundError || err instanceof SmplConflictError || err instanceof SmplValidationError || 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 buildRequestBody(options) {
+  const attrs = {
+    name: options.name
+  };
+  if (options.key !== void 0) attrs.key = options.key;
+  if (options.description !== void 0) attrs.description = options.description;
+  if (options.parent !== void 0) attrs.parent = options.parent;
+  if (options.values !== void 0)
+    attrs.values = options.values;
+  if (options.environments !== void 0)
+    attrs.environments = options.environments;
+  return {
+    data: {
+      id: options.id ?? null,
+      type: "config",
+      attributes: attrs
+    }
+  };
+}
+var ConfigClient = class {
+  /** @internal — used by Config instances for reconnecting and WebSocket auth. */
+  _apiKey;
+  /** @internal */
+  _baseUrl = BASE_URL;
+  /** @internal */
+  _http;
+  /** @internal */
+  constructor(apiKey, timeout) {
+    this._apiKey = apiKey;
+    const ms = timeout ?? 3e4;
+    this._http = (0, import_openapi_fetch.default)({
+      baseUrl: BASE_URL,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      },
+      // openapi-fetch custom fetch receives a pre-built Request object
+      fetch: async (request) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), ms);
+        try {
+          return await fetch(new Request(request, { signal: controller.signal }));
+        } catch (err) {
+          if (err instanceof DOMException && err.name === "AbortError") {
+            throw new SmplTimeoutError(`Request timed out after ${ms}ms`);
+          }
+          throw err;
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+    });
   }
   /**
-   * Send a GET request.
+   * Fetch a single config by key or UUID.
    *
-   * @param path - URL path relative to `baseUrl` (e.g. `/api/v1/configs`).
-   * @param params - Optional query parameters.
-   * @returns Parsed JSON response body.
+   * Exactly one of `key` or `id` must be provided.
+   *
+   * @throws {SmplNotFoundError} If no matching config exists.
    */
-  async get(path, params) {
-    return this.request("GET", path, void 0, params);
+  async get(options) {
+    const { key, id } = options;
+    if (key === void 0 === (id === void 0)) {
+      throw new Error("Exactly one of 'key' or 'id' must be provided.");
+    }
+    return id !== void 0 ? this._getById(id) : this._getByKey(key);
   }
   /**
-   * Send a POST request with a JSON body.
-   *
-   * @param path - URL path relative to `baseUrl`.
-   * @param body - JSON-serializable request body.
-   * @returns Parsed JSON response body.
+   * List all configs for the account.
    */
-  async post(path, body) {
-    return this.request("POST", path, body);
+  async list() {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/configs", {});
+      if (result.error !== void 0) await checkError(result.response, "Failed to list configs");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
+    }
+    if (!data) return [];
+    return data.data.map((r) => resourceToConfig(r, this));
   }
   /**
-   * Send a PUT request with a JSON body.
+   * Create a new config.
    *
-   * @param path - URL path relative to `baseUrl`.
-   * @param body - JSON-serializable request body.
-   * @returns Parsed JSON response body.
+   * @throws {SmplValidationError} If the server rejects the request.
    */
-  async put(path, body) {
-    return this.request("PUT", path, body);
+  async create(options) {
+    const body = buildRequestBody({
+      name: options.name,
+      key: options.key,
+      description: options.description,
+      parent: options.parent,
+      values: options.values
+    });
+    let data;
+    try {
+      const result = await this._http.POST("/api/v1/configs", { body });
+      if (result.error !== void 0) await checkError(result.response, "Failed to create config");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
+    }
+    if (!data || !data.data) throw new SmplValidationError("Failed to create config");
+    return resourceToConfig(data.data, this);
   }
   /**
-   * Send a DELETE request.
+   * Delete a config by UUID.
    *
-   * @param path - URL path relative to `baseUrl`.
-   * @returns Parsed JSON response body (empty object for 204 responses).
+   * @throws {SmplNotFoundError} If the config does not exist.
+   * @throws {SmplConflictError} If the config has child configs.
    */
-  async delete(path) {
-    return this.request("DELETE", path);
+  async delete(configId) {
+    try {
+      const result = await this._http.DELETE("/api/v1/configs/{id}", {
+        params: { path: { id: configId } }
+      });
+      if (result.error !== void 0 && result.response.status !== 204)
+        await checkError(result.response, `Failed to delete config ${configId}`);
+    } catch (err) {
+      wrapFetchError(err);
+    }
   }
   /**
-   * Core request method. Handles headers, timeouts, and error mapping.
+   * Internal: PUT a full config update and return the updated model.
+   *
+   * Called by {@link Config} instance methods.
+   * @internal
    */
-  async request(method, path, body, params) {
-    let url = `${this.baseUrl}${path}`;
-    if (params) {
-      const searchParams = new URLSearchParams(params);
-      url += `?${searchParams.toString()}`;
-    }
-    const headers = {
-      Authorization: buildAuthHeader(this.apiKey),
-      "User-Agent": `smplkit-typescript-sdk/${SDK_VERSION}`,
-      Accept: "application/vnd.api+json"
-    };
-    if (body !== void 0) {
-      headers["Content-Type"] = "application/vnd.api+json";
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    let response;
+  async _updateConfig(payload) {
+    const body = buildRequestBody({
+      id: payload.configId,
+      name: payload.name,
+      key: payload.key,
+      description: payload.description,
+      parent: payload.parent,
+      values: payload.values,
+      environments: payload.environments
+    });
+    let data;
     try {
-      response = await fetch(url, {
-        method,
-        headers,
-        body: body !== void 0 ? JSON.stringify(body) : void 0,
-        signal: controller.signal
+      const result = await this._http.PUT("/api/v1/configs/{id}", {
+        params: { path: { id: payload.configId } },
+        body
       });
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw new SmplTimeoutError(`Request timed out after ${this.timeout}ms`);
-      }
-      if (error instanceof TypeError) {
-        throw new SmplConnectionError(`Network error: ${error.message}`);
-      }
-      throw new SmplConnectionError(
-        `Request failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    } finally {
-      clearTimeout(timeoutId);
-    }
-    if (response.status === 204) {
-      return {};
-    }
-    const responseText = await response.text();
-    if (!response.ok) {
-      this.throwForStatus(response.status, responseText);
+      if (result.error !== void 0)
+        await checkError(result.response, `Failed to update config ${payload.configId}`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
     }
+    if (!data || !data.data)
+      throw new SmplValidationError(`Failed to update config ${payload.configId}`);
+    return resourceToConfig(data.data, this);
+  }
+  // ---- Private helpers ----
+  async _getById(configId) {
+    let data;
     try {
-      return JSON.parse(responseText);
-    } catch {
-      throw new SmplError(`Invalid JSON response: ${responseText}`, response.status, responseText);
+      const result = await this._http.GET("/api/v1/configs/{id}", {
+        params: { path: { id: configId } }
+      });
+      if (result.error !== void 0)
+        await checkError(result.response, `Config ${configId} not found`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
     }
+    if (!data || !data.data) throw new SmplNotFoundError(`Config ${configId} not found`);
+    return resourceToConfig(data.data, this);
   }
-  /**
-   * Map HTTP error status codes to typed SDK exceptions.
-   *
-   * @throws {SmplNotFoundError} On 404.
-   * @throws {SmplConflictError} On 409.
-   * @throws {SmplValidationError} On 422.
-   * @throws {SmplError} On any other non-2xx status.
-   */
-  throwForStatus(status, body) {
-    switch (status) {
-      case 404:
-        throw new SmplNotFoundError(body, 404, body);
-      case 409:
-        throw new SmplConflictError(body, 409, body);
-      case 422:
-        throw new SmplValidationError(body, 422, body);
-      default:
-        throw new SmplError(`HTTP ${status}: ${body}`, status, body);
+  async _getByKey(key) {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/configs", {
+        params: { query: { "filter[key]": key } }
+      });
+      if (result.error !== void 0)
+        await checkError(result.response, `Config with key '${key}' not found`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
+    }
+    if (!data || !data.data || data.data.length === 0) {
+      throw new SmplNotFoundError(`Config with key '${key}' not found`);
     }
+    return resourceToConfig(data.data[0], this);
   }
 };
 
 // src/client.ts
-var DEFAULT_BASE_URL = "https://config.smplkit.com";
 var SmplkitClient = class {
   /** Client for config management-plane operations. */
   config;
-  /** @internal */
-  transport;
   constructor(options) {
     if (!options.apiKey) {
       throw new Error("apiKey is required");
     }
-    this.transport = new Transport({
-      apiKey: options.apiKey,
-      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
-      timeout: options.timeout
-    });
-    this.config = new ConfigClient(this.transport);
+    this.config = new ConfigClient(options.apiKey, options.timeout);
   }
 };
+
+// src/index.ts
+init_runtime();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Config,
   ConfigClient,
+  ConfigRuntime,
   SmplConflictError,
   SmplConnectionError,
   SmplError,