@smplkit/sdk 3.0.50 → 3.0.52

package/dist/index.d.cts

@@ -106,27 +106,54 @@ interface HttpHeader {
  * {@link FORWARDER_TYPES} for callers that need to iterate.
  */
 type ForwarderType = "HTTP" | "DATADOG" | "SPLUNK_HEC" | "SUMO_LOGIC" | "NEW_RELIC" | "HONEYCOMB" | "ELASTIC";
-interface ForwarderHttp {
+/**
+ * Transport-specific delivery configuration. Today every destination
+ * type uses HTTP; future transports (FTP, SQS, ...) will join this as
+ * members of a discriminated union under {@link Forwarder.configuration}.
+ */
+interface HttpConfiguration {
+    /** HTTP method: GET, POST, PUT, PATCH, or DELETE. */
     method: string;
+    /** Destination URL. */
     url: string;
+    /** HTTP headers attached to each delivery request. */
     headers: HttpHeader[];
-    body: string | null;
     /**
-     * 3-character string: an exact HTTP code (e.g. `"200"`, `"204"`) or a
-     * class (`"2xx"`, `"3xx"`, `"4xx"`, `"5xx"`).
+     * Either an exact HTTP code (e.g. `"200"`, `"204"`) or a status class
+     * (`"1xx"`, `"2xx"`, `"3xx"`, `"4xx"`, `"5xx"`).
      */
     successStatus: string;
 }
+/**
+ * Engine used to evaluate {@link Forwarder.transform}. Must be set
+ * whenever `transform` is set. Today only `JSONATA` is supported.
+ */
+type TransformType = "JSONATA";
 interface Forwarder {
+    /** UUID assigned by the server at creation time. */
     id: string;
     name: string;
-    slug: string;
+    /** Free-text description for the forwarder. */
+    description: string | null;
     forwarderType: ForwarderType;
     enabled: boolean;
     filter: Record<string, unknown> | null;
-    transform: string | null;
-    /** Header values are returned redacted on reads. */
-    http: ForwarderHttp;
+    /**
+     * Engine used to evaluate {@link transform}. Paired 1:1 with
+     * `transform` — both set, or both `null`.
+     */
+    transformType: TransformType | null;
+    /**
+     * Template applied to each event before delivery. Shape depends on
+     * {@link transformType}; for `JSONATA`, a string containing a JSONata
+     * expression. `null` when no transform is configured.
+     */
+    transform: unknown | null;
+    /**
+     * Transport-specific delivery configuration. Header values are
+     * returned redacted on reads.
+     */
+    configuration: HttpConfiguration;
     createdAt: string | null;
     updatedAt: string | null;
     deletedAt: string | null;
@@ -135,10 +162,13 @@ interface Forwarder {
 interface CreateForwarderInput {
     name: string;
     forwarderType: ForwarderType;
-    http: ForwarderHttp;
+    configuration: HttpConfiguration;
     enabled?: boolean;
+    description?: string;
     filter?: Record<string, unknown>;
-    transform?: string;
+    /** Required when {@link transform} is set; today must be `"JSONATA"`. */
+    transformType?: TransformType;
+    transform?: unknown;
 }
 interface UpdateForwarderInput extends CreateForwarderInput {
 }
@@ -2632,22 +2662,20 @@ declare enum LogLevel {
     SILENT = "SILENT"
 }
 /**
- * Describes a logger configuration change. Frozen — fields cannot be
+ * Describes a logger effective-level change. Frozen — fields cannot be
  * mutated after construction so a listener cannot affect later listeners.
  *
- * The `level` field is a TypeScript-SDK-only convenience for callers that
- * want to act on the new effective level without re-fetching the logger.
+ * One instance per logger whose effective level moved; emitted in lockstep
+ * with the matching `adapter.applyLevel(...)` call.
  */
 declare class LoggerChangeEvent {
     readonly id: string;
     readonly source: string;
-    readonly level?: LogLevel | null;
-    readonly deleted?: true;
+    readonly level: LogLevel;
     constructor(fields: {
         id: string;
         source: string;
-        level?: LogLevel | null;
-        deleted?: true;
+        level: LogLevel;
     });
 }
 /**
@@ -3446,15 +3474,17 @@ declare class LoggingClient {
     /**
      * Refresh resolved levels and apply them to adapter-known loggers.
      *
-     * Computes a resolved level (via {@link resolveLevel}) for every entry
-     * currently in `_loggersCache` *and* every adapter-known logger name —
-     * even loggers whose own `level` is `null`, because they may inherit
-     * via group chain or dot-notation ancestry.
+     * Walks every adapter-known logger name through {@link resolveLevel}
+     * (env override → base → group chain → dot-notation ancestry → fallback)
+     * and pushes the result to every registered adapter. Loggers whose own
+     * `level` is `null` are still applied — that's the whole point of group
+     * inheritance and dot-notation ancestry.
      *
-     * The full resolved-level snapshot is stored in `_resolvedLevelStore`
-     * so callers can diff pre-vs-post and fire change listeners on actual
-     * effective-level deltas (group-driven changes included). Adapter pushes
-     * only happen for adapter-known names where `managed !== false`.
+     * The resolved-level snapshot lives in `_resolvedLevelStore` so callers
+     * can diff pre-vs-post and fire change listeners on actual effective-
+     * level deltas. The store is scoped to adapter-known names: listener
+     * fanout pairs 1:1 with `adapter.applyLevel` calls, so a logger that
+     * the adapter doesn't know about has no apply and no listener fire.
      * @internal
      */
     private _applyLevels;
@@ -3475,19 +3505,25 @@ declare class LoggingClient {
     private _handleGroupChanged;
     private _handleGroupDeleted;
     /**
-     * @internal Fire change listeners for every logger whose resolved level
-     * changed between `pre` and `post`. Stores resolved levels, not raw
-     * `logger.level`, so a group-driven change actually fires. Keys that
-     * disappeared from `post` are emitted with `deleted: true`.
+     * @internal Fire change listeners for every logger whose effective level
+     * changed between `pre` and `post`.
+     *
+     * Contract:
+     *   - Iterates loggers present in `post` (the post-apply resolved store).
+     *     A key in `pre` but not in `post` is a cache eviction — that key
+     *     itself fires nothing. Dependents that re-resolved to a new value
+     *     are still in `post` and fire normally.
+     *   - For every changed logger, fires every global listener once with
+     *     that logger's own payload (no "summary" event), then fires every
+     *     key-scoped listener registered for that id.
+     *   - One adapter.applyLevel call ↔ one listener notification per
+     *     subscriber. A trigger that moves N loggers fires the global
+     *     listener N times, not once.
+     *   - `suppressIds` is the deletion-event escape hatch: a deleted id
+     *     fires nothing for itself even when its adapter-known resolved
+     *     level moved (e.g. fell back to INFO).
      */
     private _fireDeltas;
-    /**
-     * @internal Always emit a deleted event for `id` on global and per-key
-     * listeners. Used by `logger_deleted` / `group_deleted` handlers to
-     * preserve the explicit notification contract even when nothing in the
-     * resolved-level store changed (e.g. server removed an unknown logger).
-     */
-    private _emitDeletedEvent;
     private _handleLoggersChanged;
     /**
      * Full refetch of loggers + log_groups, rebuild the caches, re-resolve

package/dist/index.d.ts

@@ -106,27 +106,54 @@ interface HttpHeader {
  * {@link FORWARDER_TYPES} for callers that need to iterate.
  */
 type ForwarderType = "HTTP" | "DATADOG" | "SPLUNK_HEC" | "SUMO_LOGIC" | "NEW_RELIC" | "HONEYCOMB" | "ELASTIC";
-interface ForwarderHttp {
+/**
+ * Transport-specific delivery configuration. Today every destination
+ * type uses HTTP; future transports (FTP, SQS, ...) will join this as
+ * members of a discriminated union under {@link Forwarder.configuration}.
+ */
+interface HttpConfiguration {
+    /** HTTP method: GET, POST, PUT, PATCH, or DELETE. */
     method: string;
+    /** Destination URL. */
     url: string;
+    /** HTTP headers attached to each delivery request. */
     headers: HttpHeader[];
-    body: string | null;
     /**
-     * 3-character string: an exact HTTP code (e.g. `"200"`, `"204"`) or a
-     * class (`"2xx"`, `"3xx"`, `"4xx"`, `"5xx"`).
+     * Either an exact HTTP code (e.g. `"200"`, `"204"`) or a status class
+     * (`"1xx"`, `"2xx"`, `"3xx"`, `"4xx"`, `"5xx"`).
      */
     successStatus: string;
 }
+/**
+ * Engine used to evaluate {@link Forwarder.transform}. Must be set
+ * whenever `transform` is set. Today only `JSONATA` is supported.
+ */
+type TransformType = "JSONATA";
 interface Forwarder {
+    /** UUID assigned by the server at creation time. */
     id: string;
     name: string;
-    slug: string;
+    /** Free-text description for the forwarder. */
+    description: string | null;
     forwarderType: ForwarderType;
     enabled: boolean;
     filter: Record<string, unknown> | null;
-    transform: string | null;
-    /** Header values are returned redacted on reads. */
-    http: ForwarderHttp;
+    /**
+     * Engine used to evaluate {@link transform}. Paired 1:1 with
+     * `transform` — both set, or both `null`.
+     */
+    transformType: TransformType | null;
+    /**
+     * Template applied to each event before delivery. Shape depends on
+     * {@link transformType}; for `JSONATA`, a string containing a JSONata
+     * expression. `null` when no transform is configured.
+     */
+    transform: unknown | null;
+    /**
+     * Transport-specific delivery configuration. Header values are
+     * returned redacted on reads.
+     */
+    configuration: HttpConfiguration;
     createdAt: string | null;
     updatedAt: string | null;
     deletedAt: string | null;
@@ -135,10 +162,13 @@ interface Forwarder {
 interface CreateForwarderInput {
     name: string;
     forwarderType: ForwarderType;
-    http: ForwarderHttp;
+    configuration: HttpConfiguration;
     enabled?: boolean;
+    description?: string;
     filter?: Record<string, unknown>;
-    transform?: string;
+    /** Required when {@link transform} is set; today must be `"JSONATA"`. */
+    transformType?: TransformType;
+    transform?: unknown;
 }
 interface UpdateForwarderInput extends CreateForwarderInput {
 }
@@ -2632,22 +2662,20 @@ declare enum LogLevel {
     SILENT = "SILENT"
 }
 /**
- * Describes a logger configuration change. Frozen — fields cannot be
+ * Describes a logger effective-level change. Frozen — fields cannot be
  * mutated after construction so a listener cannot affect later listeners.
  *
- * The `level` field is a TypeScript-SDK-only convenience for callers that
- * want to act on the new effective level without re-fetching the logger.
+ * One instance per logger whose effective level moved; emitted in lockstep
+ * with the matching `adapter.applyLevel(...)` call.
  */
 declare class LoggerChangeEvent {
     readonly id: string;
     readonly source: string;
-    readonly level?: LogLevel | null;
-    readonly deleted?: true;
+    readonly level: LogLevel;
     constructor(fields: {
         id: string;
         source: string;
-        level?: LogLevel | null;
-        deleted?: true;
+        level: LogLevel;
     });
 }
 /**
@@ -3446,15 +3474,17 @@ declare class LoggingClient {
     /**
      * Refresh resolved levels and apply them to adapter-known loggers.
      *
-     * Computes a resolved level (via {@link resolveLevel}) for every entry
-     * currently in `_loggersCache` *and* every adapter-known logger name —
-     * even loggers whose own `level` is `null`, because they may inherit
-     * via group chain or dot-notation ancestry.
+     * Walks every adapter-known logger name through {@link resolveLevel}
+     * (env override → base → group chain → dot-notation ancestry → fallback)
+     * and pushes the result to every registered adapter. Loggers whose own
+     * `level` is `null` are still applied — that's the whole point of group
+     * inheritance and dot-notation ancestry.
      *
-     * The full resolved-level snapshot is stored in `_resolvedLevelStore`
-     * so callers can diff pre-vs-post and fire change listeners on actual
-     * effective-level deltas (group-driven changes included). Adapter pushes
-     * only happen for adapter-known names where `managed !== false`.
+     * The resolved-level snapshot lives in `_resolvedLevelStore` so callers
+     * can diff pre-vs-post and fire change listeners on actual effective-
+     * level deltas. The store is scoped to adapter-known names: listener
+     * fanout pairs 1:1 with `adapter.applyLevel` calls, so a logger that
+     * the adapter doesn't know about has no apply and no listener fire.
      * @internal
      */
     private _applyLevels;
@@ -3475,19 +3505,25 @@ declare class LoggingClient {
     private _handleGroupChanged;
     private _handleGroupDeleted;
     /**
-     * @internal Fire change listeners for every logger whose resolved level
-     * changed between `pre` and `post`. Stores resolved levels, not raw
-     * `logger.level`, so a group-driven change actually fires. Keys that
-     * disappeared from `post` are emitted with `deleted: true`.
+     * @internal Fire change listeners for every logger whose effective level
+     * changed between `pre` and `post`.
+     *
+     * Contract:
+     *   - Iterates loggers present in `post` (the post-apply resolved store).
+     *     A key in `pre` but not in `post` is a cache eviction — that key
+     *     itself fires nothing. Dependents that re-resolved to a new value
+     *     are still in `post` and fire normally.
+     *   - For every changed logger, fires every global listener once with
+     *     that logger's own payload (no "summary" event), then fires every
+     *     key-scoped listener registered for that id.
+     *   - One adapter.applyLevel call ↔ one listener notification per
+     *     subscriber. A trigger that moves N loggers fires the global
+     *     listener N times, not once.
+     *   - `suppressIds` is the deletion-event escape hatch: a deleted id
+     *     fires nothing for itself even when its adapter-known resolved
+     *     level moved (e.g. fell back to INFO).
      */
     private _fireDeltas;
-    /**
-     * @internal Always emit a deleted event for `id` on global and per-key
-     * listeners. Used by `logger_deleted` / `group_deleted` handlers to
-     * preserve the explicit notification contract even when nothing in the
-     * resolved-level store changed (e.g. server removed an unknown logger).
-     */
-    private _emitDeletedEvent;
     private _handleLoggersChanged;
     /**
      * Full refetch of loggers + log_groups, rebuild the caches, re-resolve

package/dist/index.js

@@ -19221,12 +19221,10 @@ var LoggerChangeEvent = class {
   id;
   source;
   level;
-  deleted;
   constructor(fields) {
     this.id = fields.id;
     this.source = fields.source;
-    if (fields.level !== void 0) this.level = fields.level;
-    if (fields.deleted) this.deleted = fields.deleted;
+    this.level = fields.level;
     Object.freeze(this);
   }
 };
@@ -19868,16 +19866,15 @@ function _paginationFromBody2(body) {
   }
   return out;
 }
-function _httpToWire(http) {
+function _configurationToWire(config) {
   return {
-    method: http.method,
-    url: http.url,
-    headers: http.headers.map((h) => ({ name: h.name, value: h.value })),
-    body: http.body,
-    success_status: http.successStatus
+    method: config.method,
+    url: config.url,
+    headers: config.headers.map((h) => ({ name: h.name, value: h.value })),
+    success_status: config.successStatus
   };
 }
-function _httpFromWire(raw) {
+function _configurationFromWire(raw) {
   const r = raw ?? {};
   const headers = (r.headers ?? []).map((h) => ({
     name: String(h.name ?? ""),
@@ -19887,7 +19884,6 @@ function _httpFromWire(raw) {
     method: String(r.method ?? "POST"),
     url: String(r.url ?? ""),
     headers,
-    body: r.body ?? null,
     successStatus: String(r.success_status ?? "2xx")
   };
 }
@@ -19896,11 +19892,13 @@ function _forwarderAttributes(input) {
     name: input.name,
     forwarder_type: input.forwarderType,
     enabled: input.enabled ?? true,
-    http: _httpToWire(input.http)
+    configuration: _configurationToWire(input.configuration)
   };
+  if (input.description !== void 0) attrs.description = input.description;
   if (input.filter !== void 0) {
     attrs.filter = input.filter;
   }
+  if (input.transformType !== void 0) attrs.transform_type = input.transformType;
   if (input.transform !== void 0) attrs.transform = input.transform;
   return attrs;
 }
@@ -19909,12 +19907,13 @@ function _forwarderFromResource(resource) {
   return {
     id: resource.id,
     name: String(a.name ?? ""),
-    slug: String(a.slug ?? ""),
+    description: a.description ?? null,
     forwarderType: a.forwarder_type,
     enabled: Boolean(a.enabled ?? true),
     filter: a.filter ?? null,
+    transformType: a.transform_type ?? null,
     transform: a.transform ?? null,
-    http: _httpFromWire(a.http),
+    configuration: _configurationFromWire(a.configuration),
     createdAt: a.created_at ?? null,
     updatedAt: a.updated_at ?? null,
     deletedAt: a.deleted_at ?? null,
@@ -22150,27 +22149,24 @@ var LoggingClient = class {
   /**
    * Refresh resolved levels and apply them to adapter-known loggers.
    *
-   * Computes a resolved level (via {@link resolveLevel}) for every entry
-   * currently in `_loggersCache` *and* every adapter-known logger name —
-   * even loggers whose own `level` is `null`, because they may inherit
-   * via group chain or dot-notation ancestry.
+   * Walks every adapter-known logger name through {@link resolveLevel}
+   * (env override → base → group chain → dot-notation ancestry → fallback)
+   * and pushes the result to every registered adapter. Loggers whose own
+   * `level` is `null` are still applied — that's the whole point of group
+   * inheritance and dot-notation ancestry.
    *
-   * The full resolved-level snapshot is stored in `_resolvedLevelStore`
-   * so callers can diff pre-vs-post and fire change listeners on actual
-   * effective-level deltas (group-driven changes included). Adapter pushes
-   * only happen for adapter-known names where `managed !== false`.
+   * The resolved-level snapshot lives in `_resolvedLevelStore` so callers
+   * can diff pre-vs-post and fire change listeners on actual effective-
+   * level deltas. The store is scoped to adapter-known names: listener
+   * fanout pairs 1:1 with `adapter.applyLevel` calls, so a logger that
+   * the adapter doesn't know about has no apply and no listener fire.
    * @internal
    */
   _applyLevels() {
     const environment = this._parent?._environment ?? "";
     const newResolved = {};
-    for (const id of Object.keys(this._loggersCache)) {
-      newResolved[id] = resolveLevel(id, environment, this._loggersCache, this._groupsCache);
-    }
     for (const name of this._knownLoggerNames) {
-      if (!(name in newResolved)) {
-        newResolved[name] = resolveLevel(name, environment, this._loggersCache, this._groupsCache);
-      }
+      newResolved[name] = resolveLevel(name, environment, this._loggersCache, this._groupsCache);
     }
     this._resolvedLevelStore = newResolved;
     for (const name of this._knownLoggerNames) {
@@ -22303,7 +22299,6 @@ var LoggingClient = class {
     delete this._loggersCache[id];
     const preResolved = { ...this._resolvedLevelStore };
     this._applyLevels();
-    this._emitDeletedEvent(id, "websocket");
     this._fireDeltas(preResolved, this._resolvedLevelStore, "websocket", /* @__PURE__ */ new Set([id]));
   };
   _handleGroupChanged = (data) => {
@@ -22333,45 +22328,41 @@ var LoggingClient = class {
     delete this._groupsCache[id];
     const preResolved = { ...this._resolvedLevelStore };
     this._applyLevels();
-    this._emitDeletedEvent(id, "websocket");
     this._fireDeltas(preResolved, this._resolvedLevelStore, "websocket", /* @__PURE__ */ new Set([id]));
   };
   /**
-   * @internal Fire change listeners for every logger whose resolved level
-   * changed between `pre` and `post`. Stores resolved levels, not raw
-   * `logger.level`, so a group-driven change actually fires. Keys that
-   * disappeared from `post` are emitted with `deleted: true`.
+   * @internal Fire change listeners for every logger whose effective level
+   * changed between `pre` and `post`.
+   *
+   * Contract:
+   *   - Iterates loggers present in `post` (the post-apply resolved store).
+   *     A key in `pre` but not in `post` is a cache eviction — that key
+   *     itself fires nothing. Dependents that re-resolved to a new value
+   *     are still in `post` and fire normally.
+   *   - For every changed logger, fires every global listener once with
+   *     that logger's own payload (no "summary" event), then fires every
+   *     key-scoped listener registered for that id.
+   *   - One adapter.applyLevel call ↔ one listener notification per
+   *     subscriber. A trigger that moves N loggers fires the global
+   *     listener N times, not once.
+   *   - `suppressIds` is the deletion-event escape hatch: a deleted id
+   *     fires nothing for itself even when its adapter-known resolved
+   *     level moved (e.g. fell back to INFO).
    */
-  _fireDeltas(pre, post, source, excludeIds) {
-    const changed = [];
-    const allKeys = /* @__PURE__ */ new Set([...Object.keys(pre), ...Object.keys(post)]);
-    for (const k of allKeys) {
-      if (excludeIds?.has(k)) continue;
-      if (pre[k] !== post[k]) changed.push(k);
-    }
-    if (changed.length === 0) return;
-    const buildEvent = (id) => {
-      const isDeletion = id in pre && !(id in post);
-      const fields = {
-        id,
-        source,
-        level: post[id] ?? null
-      };
-      if (isDeletion) fields.deleted = true;
-      return new LoggerChangeEvent(fields);
-    };
-    const firstKey = changed[0];
-    const globalEvent = buildEvent(firstKey);
-    for (const cb of this._globalListeners) {
-      try {
-        cb(globalEvent);
-      } catch {
+  _fireDeltas(pre, post, source, suppressIds) {
+    for (const id of Object.keys(post)) {
+      if (suppressIds?.has(id)) continue;
+      const next = post[id];
+      if (pre[id] === next) continue;
+      const event = new LoggerChangeEvent({ id, source, level: next });
+      for (const cb of this._globalListeners) {
+        try {
+          cb(event);
+        } catch {
+        }
       }
-    }
-    for (const k of changed) {
-      const keyCallbacks = this._keyListeners.get(k);
+      const keyCallbacks = this._keyListeners.get(id);
       if (keyCallbacks) {
-        const event = buildEvent(k);
         for (const cb of keyCallbacks) {
           try {
             cb(event);
@@ -22381,43 +22372,6 @@ var LoggingClient = class {
       }
     }
   }
-  /**
-   * @internal Always emit a deleted event for `id` on global and per-key
-   * listeners. Used by `logger_deleted` / `group_deleted` handlers to
-   * preserve the explicit notification contract even when nothing in the
-   * resolved-level store changed (e.g. server removed an unknown logger).
-   */
-  _emitDeletedEvent(id, source) {
-    const event = new LoggerChangeEvent({
-      id,
-      level: null,
-      source,
-      deleted: true
-    });
-    for (const cb of this._globalListeners) {
-      try {
-        cb(event);
-      } catch (err) {
-        debug(
-          "websocket",
-          `deleted listener error: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    const idCallbacks = this._keyListeners.get(id);
-    if (idCallbacks) {
-      for (const cb of idCallbacks) {
-        try {
-          cb(event);
-        } catch (err) {
-          debug(
-            "websocket",
-            `deleted key listener error: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
-    }
-  }
   _handleLoggersChanged = (_data) => {
     debug("websocket", `loggers_changed event received`);
     void this._resolveAndFire("websocket").catch(() => {