@smplkit/sdk 3.0.50 → 3.0.51

package/dist/index.d.cts

@@ -2632,22 +2632,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 +3444,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 +3475,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

@@ -2632,22 +2632,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 +3444,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 +3475,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);
   }
 };
@@ -22150,27 +22148,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 +22298,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 +22327,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 +22371,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(() => {