@sanctuary-framework/mcp-server 1.2.11 → 1.2.12

package/dist/index.cjs

@@ -16711,6 +16711,276 @@ var COORDINATION_VIEW_AUDIT_OPS = {
   ENTRY_DRILLED: "operator_handoff_entry_drilled"
 };
 
+// src/coordination/context-transfer-extractor.ts
+var SUMMARY_MAX_CHARS = 240;
+var CATEGORY_VALUES = [
+  "memory",
+  "credentials",
+  "plans",
+  "outputs",
+  "audit-refs",
+  "other"
+];
+async function extractContextTransferBreakdown(detail, deps = {}) {
+  const pathA = tryStructuredPath(detail);
+  if (pathA) return pathA;
+  const pathB = tryCompositionPath(detail);
+  if (pathB) return pathB;
+  const pathC = tryHeuristicPath(detail);
+  if (pathC.confidence >= 0.5 || !deps.substrateSelector) {
+    return pathC;
+  }
+  const assist = await tryLlmAssistPath(detail, deps.substrateSelector);
+  return assist ?? pathC;
+}
+function tryStructuredPath(detail) {
+  const details = sourceDetails(detail.source_audit_entry);
+  if (!details) return null;
+  const transferredRaw = details["transferred"];
+  const withheldRaw = details["withheld"];
+  if (transferredRaw === void 0 && withheldRaw === void 0) return null;
+  const transferred = parseExplicitContextItems(transferredRaw);
+  const withheld = parseExplicitContextItems(withheldRaw);
+  return {
+    handoff_entry_id: detail.entry.entry_id,
+    transferred,
+    withheld,
+    source: "structured",
+    confidence: 1
+  };
+}
+function tryCompositionPath(detail) {
+  const op = detail.source_audit_entry.operation;
+  if (!op.startsWith("composition_completed")) return null;
+  const details = sourceDetails(detail.source_audit_entry);
+  if (!details) return null;
+  const receiptRaw = details["receipt"];
+  const sourceStateRaw = details["source_state_snapshot"];
+  if (receiptRaw === void 0) return null;
+  const transferred = parseExplicitContextItems(receiptRaw);
+  const withheld = [];
+  if (Array.isArray(sourceStateRaw)) {
+    const transferredKeys = new Set(
+      transferred.map((t) => `${t.category}:${t.summary}`)
+    );
+    for (const item of parseExplicitContextItems(sourceStateRaw)) {
+      const key = `${item.category}:${item.summary}`;
+      if (!transferredKeys.has(key)) withheld.push(item);
+    }
+  }
+  return {
+    handoff_entry_id: detail.entry.entry_id,
+    transferred,
+    withheld,
+    source: "composition",
+    confidence: 0.9
+  };
+}
+function tryHeuristicPath(detail) {
+  const entry = detail.entry;
+  const audit = detail.source_audit_entry;
+  const details = sourceDetails(audit);
+  if (audit.operation === "cross_harness_approval_aggregated") {
+    const ruleId = optString2(details, "policy_rule_id");
+    if (ruleId) {
+      const category = categoryFromPolicyRuleId(ruleId);
+      const summary = `${ruleId} (${entry.source_agent_id} -> operator)`;
+      return {
+        handoff_entry_id: entry.entry_id,
+        transferred: [
+          {
+            category,
+            summary: truncate(summary, SUMMARY_MAX_CHARS),
+            size_hint: "minimal"
+          }
+        ],
+        withheld: [],
+        source: "heuristic",
+        confidence: 0.5
+      };
+    }
+  }
+  if (audit.operation === "v1.1_local_handoff") {
+    const reasonClass = optString2(details, "reason_class");
+    const newStatus = optString2(details, "new_status");
+    const previousStatus = optString2(details, "previous_status");
+    const transferred = [];
+    const withheld = [];
+    if (newStatus === "denied" || newStatus === "failed") {
+      withheld.push({
+        category: "other",
+        summary: truncate(
+          `handoff ${newStatus}${reasonClass ? ` (${reasonClass})` : ""}: ${entry.source_agent_id} -> ${entry.target_agent_id}`,
+          SUMMARY_MAX_CHARS
+        ),
+        size_hint: "minimal"
+      });
+    } else if (newStatus === "accepted" || newStatus === "completed") {
+      transferred.push({
+        category: "other",
+        summary: truncate(
+          `handoff ${newStatus}${previousStatus ? ` (from ${previousStatus})` : ""}: ${entry.source_agent_id} -> ${entry.target_agent_id}`,
+          SUMMARY_MAX_CHARS
+        ),
+        size_hint: "small"
+      });
+    } else {
+      transferred.push({
+        category: "other",
+        summary: truncate(
+          `handoff ${entry.source_agent_id} -> ${entry.target_agent_id}${newStatus ? ` (${newStatus})` : ""}`,
+          SUMMARY_MAX_CHARS
+        ),
+        size_hint: "minimal"
+      });
+    }
+    return {
+      handoff_entry_id: entry.entry_id,
+      transferred,
+      withheld,
+      source: "heuristic",
+      confidence: reasonClass || newStatus ? 0.5 : 0.3
+    };
+  }
+  return {
+    handoff_entry_id: entry.entry_id,
+    transferred: [
+      {
+        category: "other",
+        summary: truncate(
+          `handoff ${entry.source_agent_id} -> ${entry.target_agent_id}`,
+          SUMMARY_MAX_CHARS
+        ),
+        size_hint: "minimal"
+      }
+    ],
+    withheld: [],
+    source: "heuristic",
+    confidence: 0.3
+  };
+}
+async function tryLlmAssistPath(detail, selector) {
+  const entry = detail.entry;
+  const audit = detail.source_audit_entry;
+  const probe = `event=${audit.operation} sender=${entry.source_agent_id} target=${entry.target_agent_id} summary=${entry.context_transfer_summary}`;
+  try {
+    const response = await selector.invokeClassify("sentinel-scoring", {
+      kind: "classify",
+      items: [probe],
+      categories: [...CATEGORY_VALUES]
+    });
+    if (response.body.kind !== "classify") return null;
+    const top = response.body.results[0];
+    if (!top || !isCategory(top.category) || top.confidence < 0.4) {
+      return null;
+    }
+    return {
+      handoff_entry_id: entry.entry_id,
+      transferred: [
+        {
+          category: top.category,
+          summary: truncate(
+            `LLM-classified handoff ${entry.source_agent_id} -> ${entry.target_agent_id}: ${top.category} (confidence ${top.confidence.toFixed(2)})`,
+            SUMMARY_MAX_CHARS
+          ),
+          size_hint: "minimal"
+        }
+      ],
+      withheld: [],
+      source: "llm-assist",
+      confidence: 0.6
+    };
+  } catch {
+    return null;
+  }
+}
+function sourceDetails(audit) {
+  return audit.details;
+}
+function optString2(details, key) {
+  if (!details) return null;
+  const value = details[key];
+  if (typeof value !== "string" || value.length === 0) return null;
+  return value;
+}
+function isCategory(value) {
+  return CATEGORY_VALUES.includes(value);
+}
+function truncate(s, cap) {
+  return s.length <= cap ? s : `${s.slice(0, cap - 3)}...`;
+}
+function parseExplicitContextItems(raw) {
+  if (raw === null || raw === void 0) return [];
+  if (Array.isArray(raw)) {
+    const out = [];
+    for (const entry of raw) {
+      if (typeof entry === "string") {
+        out.push({
+          category: "other",
+          summary: truncate(entry, SUMMARY_MAX_CHARS),
+          size_hint: "minimal"
+        });
+        continue;
+      }
+      if (entry && typeof entry === "object") {
+        const obj = entry;
+        const category = isCategoryValue(obj["category"]) ? obj["category"] : "other";
+        const summary = typeof obj["summary"] === "string" ? truncate(obj["summary"], SUMMARY_MAX_CHARS) : "(unspecified)";
+        const sizeHint = isSizeHintValue(obj["size_hint"]) ? obj["size_hint"] : "minimal";
+        out.push({ category, summary, size_hint: sizeHint });
+      }
+    }
+    return out;
+  }
+  if (typeof raw === "object" && raw !== null) {
+    const out = [];
+    for (const [k, v] of Object.entries(raw)) {
+      const category = isCategoryValue(k) ? k : "other";
+      if (Array.isArray(v)) {
+        for (const item of v) {
+          if (typeof item === "string") {
+            out.push({
+              category,
+              summary: truncate(item, SUMMARY_MAX_CHARS),
+              size_hint: "minimal"
+            });
+          }
+        }
+      }
+    }
+    return out;
+  }
+  return [];
+}
+function isCategoryValue(v) {
+  return typeof v === "string" && CATEGORY_VALUES.includes(v);
+}
+function isSizeHintValue(v) {
+  return typeof v === "string" && (v === "minimal" || v === "small" || v === "medium" || v === "large");
+}
+function categoryFromPolicyRuleId(ruleId) {
+  const lower = ruleId.toLowerCase();
+  if (lower.includes("credential") || lower.includes("broker_secret")) {
+    return "credentials";
+  }
+  if (lower.includes("memory") || lower.includes("state_read")) {
+    return "memory";
+  }
+  if (lower.includes("plan")) {
+    return "plans";
+  }
+  if (lower.includes("export") || lower.includes("output")) {
+    return "outputs";
+  }
+  if (lower.includes("audit")) {
+    return "audit-refs";
+  }
+  return "other";
+}
+var CONTEXT_TRANSFER_AUDIT_OPS = {
+  DECODED: "operator_handoff_context_transfer_decoded"
+};
+
 // src/coordination/handoff-routes.ts
 var COORDINATION_API_PREFIX = "/api/coordination";
 var COORDINATION_HANDOFFS_PREFIX = "/api/coordination/handoffs";
@@ -16854,7 +17124,29 @@ async function handleCoordinationRoute(deps, req, res) {
           target_agent_id: detail.entry.target_agent_id
         }
       );
-      writeJSON6(res, 200, { ok: true, data: detail });
+      let breakdown = null;
+      try {
+        breakdown = await extractContextTransferBreakdown(
+          detail,
+          deps.contextTransfer ?? {}
+        );
+        deps.auditLog.append(
+          "l2",
+          CONTEXT_TRANSFER_AUDIT_OPS.DECODED,
+          deps.operatorId,
+          {
+            fortress_id: deps.handoffLog.getFortressId(),
+            entry_id: detail.entry.entry_id,
+            extractor_path: breakdown.source,
+            confidence: breakdown.confidence,
+            transferred_count: breakdown.transferred.length,
+            withheld_count: breakdown.withheld.length
+          }
+        );
+      } catch {
+      }
+      const responseData = breakdown !== null ? { ...detail, context_transfer_breakdown: breakdown } : detail;
+      writeJSON6(res, 200, { ok: true, data: responseData });
       return true;
     }
     writeJSON6(res, 404, { ok: false, error: "not_found", path });
@@ -21311,13 +21603,33 @@ var SentinelDispatcher = class {
     }
   }
 };
+
+// src/anomaly-detection/classifier-state-store.ts
+init_encryption();
+init_encoding();
+
+// src/anomaly-detection/classifiers/cusum.ts
+var CUSUM_CLASSIFIER_ID = "cusum";
+
+// src/anomaly-detection/classifiers/psi.ts
+var PSI_CLASSIFIER_ID = "psi";
+
+// src/anomaly-detection/anomaly-pipeline.ts
 var ANOMALY_AUDIT_OPS = {
   DETECTOR_REGISTERED: "anomaly_detector_registered",
   DETECTOR_UNREGISTERED: "anomaly_detector_unregistered",
   FINDING_EMITTED: "anomaly_finding_emitted",
   EVALUATION_FAILED: "anomaly_evaluation_failed",
   TRAINING_COMPLETED: "anomaly_training_completed",
-  TRAINING_FAILED: "anomaly_training_failed"
+  TRAINING_FAILED: "anomaly_training_failed",
+  /** Chi-2: a classifier was attached to an existing detector. */
+  CLASSIFIER_SUBSCRIBED: "anomaly_classifier_subscribed",
+  /** Chi-2: a classifier was detached from an existing detector. */
+  CLASSIFIER_UNSUBSCRIBED: "anomaly_classifier_unsubscribed",
+  /** Chi-2: CUSUM-flagged mean-shift drift on a per-agent feature. */
+  CUSUM_DRIFT_DETECTED: "anomaly_cusum_drift_detected",
+  /** Chi-2: PSI-flagged distribution shift on a per-agent feature. */
+  PSI_DISTRIBUTION_SHIFT_DETECTED: "anomaly_psi_distribution_shift_detected"
 };
 var DEFAULT_TICK_INTERVAL_MS2 = 6e4;
 var AnomalyPipelineDispatcher = class {
@@ -21408,34 +21720,37 @@ var AnomalyPipelineDispatcher = class {
             const stamped = await this.routeFinding(detectorId, raw);
             findings.push(stamped);
           }
-          try {
-            const trainingResult = await detector.classifier.train();
-            this.auditLog.append(
-              "l2",
-              ANOMALY_AUDIT_OPS.TRAINING_COMPLETED,
-              this.identityId,
-              {
-                detector_id: detectorId,
-                classifier_id: detector.classifier.classifierId,
-                trained_at: trainingResult.trained_at,
-                sample_count: trainingResult.sample_count,
-                agent_count: trainingResult.agent_count,
-                fortress_id: this.fortressId
-              }
-            );
-          } catch (trainErr) {
-            const message = trainErr instanceof Error ? trainErr.message : String(trainErr);
-            this.auditLog.append(
-              "l2",
-              ANOMALY_AUDIT_OPS.TRAINING_FAILED,
-              this.identityId,
-              {
-                detector_id: detectorId,
-                error_message: message,
-                fortress_id: this.fortressId
-              },
-              "failure"
-            );
+          for (const classifier of detector.getAllClassifiers()) {
+            try {
+              const trainingResult = await classifier.train();
+              this.auditLog.append(
+                "l2",
+                ANOMALY_AUDIT_OPS.TRAINING_COMPLETED,
+                this.identityId,
+                {
+                  detector_id: detectorId,
+                  classifier_id: classifier.classifierId,
+                  trained_at: trainingResult.trained_at,
+                  sample_count: trainingResult.sample_count,
+                  agent_count: trainingResult.agent_count,
+                  fortress_id: this.fortressId
+                }
+              );
+            } catch (trainErr) {
+              const message = trainErr instanceof Error ? trainErr.message : String(trainErr);
+              this.auditLog.append(
+                "l2",
+                ANOMALY_AUDIT_OPS.TRAINING_FAILED,
+                this.identityId,
+                {
+                  detector_id: detectorId,
+                  classifier_id: classifier.classifierId,
+                  error_message: message,
+                  fortress_id: this.fortressId
+                },
+                "failure"
+              );
+            }
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -21498,6 +21813,7 @@ var AnomalyPipelineDispatcher = class {
       observed_at: raw.observed_at || this.now().toISOString()
     };
     await this.findingStore.saveFinding(stamped);
+    const classifierId = stamped.details["classifier_id"] ?? null;
     this.auditLog.append(
       "l2",
       ANOMALY_AUDIT_OPS.FINDING_EMITTED,
@@ -21507,13 +21823,79 @@ var AnomalyPipelineDispatcher = class {
         finding_id: stamped.finding_id,
         severity: stamped.severity,
         anomaly_score: stamped.details["anomaly_score"] ?? null,
+        ...classifierId !== null ? { classifier_id: classifierId } : {},
         ...stamped.agent_id !== void 0 ? { agent_id: stamped.agent_id } : {},
         fortress_id: this.fortressId
       }
     );
+    const specificOp = classifierSpecificAuditOp(classifierId);
+    if (specificOp !== null) {
+      this.auditLog.append("l2", specificOp, this.identityId, {
+        detector_id: detectorId,
+        finding_id: stamped.finding_id,
+        severity: stamped.severity,
+        anomaly_score: stamped.details["anomaly_score"] ?? null,
+        ...stamped.agent_id !== void 0 ? { agent_id: stamped.agent_id } : {},
+        fortress_id: this.fortressId
+      });
+    }
     this.emit({ type: "finding", finding: stamped });
     return stamped;
   }
+  /**
+   * Chi-2: attach an additional classifier to an already-registered
+   * detector. Emits ANOMALY_CLASSIFIER_SUBSCRIBED on success. The
+   * factory is called with the fortress AnomalyContext so the
+   * classifier can build its own state-store binding. Idempotent: a
+   * second call with the same classifierId returns false.
+   */
+  async addClassifierToDetector(detectorId, factory) {
+    const detector = this.detectors.get(detectorId);
+    if (!detector) return false;
+    const context = {
+      fortressId: this.fortressId,
+      auditLog: this.auditLog,
+      storage: this.storage,
+      masterKey: this.masterKey,
+      now: this.now
+    };
+    const classifier = factory(context);
+    const added = detector.addClassifier(classifier);
+    if (!added) return false;
+    this.auditLog.append(
+      "l2",
+      ANOMALY_AUDIT_OPS.CLASSIFIER_SUBSCRIBED,
+      this.identityId,
+      {
+        detector_id: detectorId,
+        classifier_id: classifier.classifierId,
+        fortress_id: this.fortressId
+      }
+    );
+    return true;
+  }
+  /**
+   * Chi-2: detach an additional classifier from an already-registered
+   * detector. Emits ANOMALY_CLASSIFIER_UNSUBSCRIBED on success. The
+   * primary classifier cannot be detached (returns false).
+   */
+  async removeClassifierFromDetector(detectorId, classifierId) {
+    const detector = this.detectors.get(detectorId);
+    if (!detector) return false;
+    const removed = detector.removeClassifier(classifierId);
+    if (!removed) return false;
+    this.auditLog.append(
+      "l2",
+      ANOMALY_AUDIT_OPS.CLASSIFIER_UNSUBSCRIBED,
+      this.identityId,
+      {
+        detector_id: detectorId,
+        classifier_id: classifierId,
+        fortress_id: this.fortressId
+      }
+    );
+    return true;
+  }
   emit(event) {
     for (const listener of this.listeners) {
       try {
@@ -21523,6 +21905,16 @@ var AnomalyPipelineDispatcher = class {
     }
   }
 };
+function classifierSpecificAuditOp(classifierId) {
+  if (classifierId === null) return null;
+  if (classifierId === CUSUM_CLASSIFIER_ID) {
+    return ANOMALY_AUDIT_OPS.CUSUM_DRIFT_DETECTED;
+  }
+  if (classifierId === PSI_CLASSIFIER_ID) {
+    return ANOMALY_AUDIT_OPS.PSI_DISTRIBUTION_SHIFT_DETECTED;
+  }
+  return null;
+}
 
 // src/sentinel/sentinel.ts
 var Sentinel = class {
@@ -38202,6 +38594,136 @@ function tryParseClassification3(text) {
   }
 }
 
+// src/query-anonymity/header-strip.ts
+var QUERY_ANONYMITY_AUDIT_OPS = {
+  HEADERS_STRIPPED: "query_anonymity_headers_stripped"
+};
+var CANONICAL_STRIP_LIST = [
+  // Browser / runtime fingerprinting.
+  { name: "user-agent", reason: "user-agent" },
+  { name: "sec-ch-ua", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-mobile", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-platform", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-platform-version", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-arch", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-bitness", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-model", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-full-version-list", reason: "fingerprintable-extension" },
+  // Locale fingerprint.
+  { name: "accept-language", reason: "locale-fingerprint" },
+  // Request-origin leak.
+  { name: "referer", reason: "leaking-network-info" },
+  { name: "referrer-policy", reason: "leaking-network-info" },
+  { name: "origin", reason: "leaking-network-info" },
+  // Forwarded-by / IP-derived network info.
+  { name: "via", reason: "leaking-network-info" },
+  { name: "forwarded", reason: "leaking-network-info" },
+  { name: "x-forwarded-for", reason: "leaking-network-info" },
+  { name: "x-real-ip", reason: "leaking-network-info" },
+  { name: "x-client-ip", reason: "leaking-network-info" },
+  // DNT / GPC are technically anti-tracking signals but they
+  // themselves form a fingerprint (operators who set DNT=1 are a
+  // smaller subset). Strip to keep the substrate ignorant of
+  // operator preferences.
+  { name: "dnt", reason: "unnecessary-metadata" },
+  { name: "sec-gpc", reason: "unnecessary-metadata" }
+];
+var REQUIRED_HEADERS = [
+  "authorization",
+  "content-type",
+  "content-length",
+  "host",
+  "accept",
+  "x-api-key",
+  // Anthropic API auth
+  "anthropic-version",
+  // Anthropic API contract version
+  "anthropic-beta",
+  // optional Anthropic beta opt-in
+  "openai-organization",
+  // optional OpenAI org id
+  "x-stainless-package-version",
+  // allowed for Anthropic + OpenAI SDK contract compat
+  "x-goog-api-key",
+  // Google AI Studio
+  "x-goog-user-project"
+  // Google AI Studio
+];
+var REQUIRED_HEADER_SET = new Set(
+  REQUIRED_HEADERS.map((h) => h.toLowerCase())
+);
+var STRIP_REASON_BY_NAME = new Map(
+  CANONICAL_STRIP_LIST.map((h) => [h.name.toLowerCase(), h.reason])
+);
+function stripHeaders(headers) {
+  const stripped = {};
+  const removed = [];
+  for (const [name, value] of Object.entries(headers)) {
+    const lower = name.toLowerCase();
+    if (REQUIRED_HEADER_SET.has(lower)) {
+      stripped[name] = value;
+      continue;
+    }
+    const reason = STRIP_REASON_BY_NAME.get(lower);
+    if (reason !== void 0) {
+      removed.push({ name, reason });
+      continue;
+    }
+    stripped[name] = value;
+  }
+  return { stripped, removed };
+}
+function defeatUndiciDefaultsInto(headers) {
+  if (headers["user-agent"] === void 0 && headers["User-Agent"] === void 0) {
+    headers["User-Agent"] = "";
+  }
+  if (headers["accept-language"] === void 0 && headers["Accept-Language"] === void 0) {
+    headers["Accept-Language"] = "";
+  }
+  return headers;
+}
+function createAnonymizedFetch(baseFetch, onAudit) {
+  const wrapped = async (input, init) => {
+    const headers = normalizeHeadersInit(init?.headers);
+    const result = stripHeaders(headers);
+    defeatUndiciDefaultsInto(result.stripped);
+    const preservedRequired = Object.keys(result.stripped).filter(
+      (k) => REQUIRED_HEADER_SET.has(k.toLowerCase())
+    );
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+    if (onAudit) {
+      onAudit({
+        url,
+        method,
+        stripped_count: result.removed.length,
+        removed: result.removed,
+        required_preserved: preservedRequired
+      });
+    }
+    return baseFetch(input, { ...init, headers: result.stripped });
+  };
+  return wrapped;
+}
+function normalizeHeadersInit(raw) {
+  if (raw === void 0) return {};
+  if (typeof Headers !== "undefined" && raw instanceof Headers) {
+    const out = {};
+    raw.forEach((value, key) => {
+      out[key] = value;
+    });
+    return out;
+  }
+  if (Array.isArray(raw)) {
+    const out = {};
+    for (const [k, v] of raw) {
+      if (k !== void 0 && v !== void 0) out[k] = v;
+    }
+    return out;
+  }
+  return { ...raw };
+}
+
 // src/intelligence/substrates/hybrid/per-surface-router.ts
 function resolveHybridChoice(rules, surface) {
   if (!rules) return null;
@@ -38262,7 +38784,21 @@ var SubstrateSelector = class {
     this.auditLog = cfg.auditLog;
     this.identityId = cfg.identityId;
     this.redactor = cfg.redactor ?? IDENTITY_REDACTOR;
-    this.fetchImpl = cfg.fetchImpl;
+    const baseFetch = cfg.fetchImpl ?? globalThis.fetch;
+    this.fetchImpl = createAnonymizedFetch(baseFetch, (event) => {
+      this.auditLog.append(
+        "l2",
+        QUERY_ANONYMITY_AUDIT_OPS.HEADERS_STRIPPED,
+        this.identityId,
+        {
+          url: event.url,
+          method: event.method,
+          stripped_count: event.stripped_count,
+          removed: event.removed,
+          required_preserved: event.required_preserved
+        }
+      );
+    });
     this.config = buildDefaultConfig();
   }
   /**