@tallyrow/safesignal 1.0.1-rc.1

package/dist/index.mjs

@@ -0,0 +1,1232 @@
+// src/context/context-merge.ts
+function mergeContexts(...sources) {
+  const merged = {};
+  for (const src of sources) {
+    if (src === void 0) continue;
+    if (src.application !== void 0) {
+      merged.application = src.application;
+    }
+    if (src.module !== void 0) {
+      merged.module = src.module;
+    }
+    if (src.environment !== void 0) {
+      merged.environment = src.environment;
+    }
+    if (src.attributes !== void 0) {
+      merged.attributes = deepMergeAttributes(
+        merged.attributes ?? {},
+        src.attributes
+      );
+    }
+  }
+  const out = {};
+  if (merged.application !== void 0) out.application = merged.application;
+  if (merged.module !== void 0) out.module = merged.module;
+  if (merged.environment !== void 0) out.environment = merged.environment;
+  if (merged.attributes !== void 0) out.attributes = merged.attributes;
+  return out;
+}
+function deepMergeAttributes(earlier, later) {
+  const result = { ...earlier };
+  for (const key of Object.keys(later)) {
+    const laterValue = later[key];
+    if (laterValue === void 0) continue;
+    const earlierValue = result[key];
+    if (isPlainAttributeObject(earlierValue) && isPlainAttributeObject(laterValue)) {
+      result[key] = deepMergeAttributes(earlierValue, laterValue);
+    } else {
+      result[key] = laterValue;
+    }
+  }
+  return result;
+}
+function isPlainAttributeObject(value) {
+  return value !== null && value !== void 0 && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/internal/errors/internal-errors.ts
+var PACKAGE_ERROR_MARKER = /* @__PURE__ */ Symbol("frontend-logging-sdk/package-error");
+var PackageError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "PackageError";
+    this.code = code;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    if (options.transportName !== void 0) {
+      this.transportName = options.transportName;
+    }
+    Object.defineProperty(this, PACKAGE_ERROR_MARKER, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+};
+function isPackageError(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return value[PACKAGE_ERROR_MARKER] === true;
+}
+function wrapAsPackageError(code, message, cause, transportName) {
+  if (isPackageError(cause)) return cause;
+  const options = { cause };
+  if (transportName !== void 0) {
+    options.transportName = transportName;
+  }
+  return new PackageError(code, message, options);
+}
+function safeNotify(onInternalError, err) {
+  try {
+    onInternalError(err);
+  } catch {
+  }
+}
+
+// src/pipeline/control-char-guard.ts
+var CONTROL_CHAR_CLASS = "[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F\\u2028\\u2029]";
+var HAS_CONTROL_CHAR = new RegExp(CONTROL_CHAR_CLASS);
+var CONTROL_CHAR_GLOBAL = new RegExp(CONTROL_CHAR_CLASS, "g");
+function escapeControlChars(value) {
+  if (!HAS_CONTROL_CHAR.test(value)) return value;
+  return value.replace(CONTROL_CHAR_GLOBAL, (ch) => {
+    const code = ch.charCodeAt(0);
+    return "\\u" + code.toString(16).padStart(4, "0");
+  });
+}
+var controlCharGuard = (event, _config) => {
+  const message = escapeControlChars(event.message);
+  const attributes = walkAttributes(event.attributes);
+  const context = walkContext(event.context);
+  let error;
+  if (event.error !== void 0) {
+    const escName = escapeControlChars(event.error.name);
+    const escMessage = escapeControlChars(event.error.message);
+    const stack = event.error.stack;
+    const escStack = stack === void 0 ? void 0 : escapeControlChars(stack);
+    if (escName === event.error.name && escMessage === event.error.message && escStack === stack) {
+      error = event.error;
+    } else {
+      error = { name: escName, message: escMessage };
+      if (escStack !== void 0) error.stack = escStack;
+    }
+  }
+  const noChange = message === event.message && attributes === event.attributes && context === event.context && error === event.error;
+  if (noChange) return event;
+  const next = {
+    timestamp: event.timestamp,
+    level: event.level,
+    message,
+    attributes,
+    context
+  };
+  if (error !== void 0) next.error = error;
+  return next;
+};
+function walkAttributes(attrs) {
+  let changed = false;
+  let result = null;
+  for (const key of Object.keys(attrs)) {
+    const value = attrs[key];
+    if (value === void 0) continue;
+    const escaped = walkValue(value);
+    if (escaped !== value) {
+      if (result === null) {
+        result = {};
+        for (const k of Object.keys(attrs)) {
+          const existing = attrs[k];
+          if (existing !== void 0) result[k] = existing;
+        }
+      }
+      result[key] = escaped;
+      changed = true;
+    }
+  }
+  return changed && result !== null ? result : attrs;
+}
+function walkValue(value) {
+  if (typeof value === "string") return escapeControlChars(value);
+  if (Array.isArray(value)) return walkArray(value);
+  if (value !== null && typeof value === "object") return walkAttributes(value);
+  return value;
+}
+function walkArray(arr) {
+  let changed = false;
+  let result = null;
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (item === void 0) continue;
+    const escaped = walkValue(item);
+    if (escaped !== item) {
+      if (result === null) result = arr.slice();
+      result[i] = escaped;
+      changed = true;
+    }
+  }
+  return changed && result !== null ? result : arr;
+}
+function walkContext(context) {
+  if (context.attributes === void 0) return context;
+  const escaped = walkAttributes(context.attributes);
+  if (escaped === context.attributes) return context;
+  return { ...context, attributes: escaped };
+}
+
+// src/pipeline/freeze.ts
+var freezeInDev = (event, _config) => {
+  deepFreeze(event);
+  return event;
+};
+function deepFreeze(value) {
+  if (Object.isFrozen(value)) return;
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    const child = value[key];
+    if (child !== null && typeof child === "object") {
+      deepFreeze(child);
+    }
+  }
+}
+
+// src/pipeline/redactor.ts
+var DEFAULT_REPLACEMENT = "[REDACTED]";
+var DEFAULT_RULES = [
+  // Key rules (immediate-name match, case-insensitive).
+  { key: /^password$|^passwd$/i },
+  { key: /^token$|access[_-]?token|refresh[_-]?token|bearer[_-]?token/i },
+  { key: /^authorization$|^auth$/i },
+  { key: /^cookie$|^set-cookie$/i },
+  { key: /^secret$/i },
+  { key: /api[_-]?key/i },
+  { key: /session[_-]?id|^sid$/i },
+  { key: /^ssn$/i },
+  { key: /credit[_-]?card|^cardNumber$|^cvv$/i },
+  // Shape rules (leaf-string match).
+  { shape: /^[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}$/ },
+  { shape: /^Bearer\s+[A-Za-z0-9._-]+$/i }
+];
+function compileRules(rules) {
+  const keyRules = [];
+  const shapeRules = [];
+  for (const rule of rules) {
+    const replacement = rule.replacement ?? DEFAULT_REPLACEMENT;
+    if (rule.key !== void 0) {
+      keyRules.push(makeKeyRule(rule.key, replacement));
+    }
+    if (rule.shape !== void 0) {
+      shapeRules.push({ pattern: rule.shape, replacement });
+    }
+  }
+  return { keyRules, shapeRules };
+}
+function makeKeyRule(key, replacement) {
+  if (typeof key === "string") {
+    const expected = key.toLowerCase();
+    return {
+      match: (candidate) => candidate.toLowerCase() === expected,
+      replacement
+    };
+  }
+  return { match: (candidate) => key.test(candidate), replacement };
+}
+function createRedactor(rules) {
+  const active2 = rules ?? DEFAULT_RULES;
+  const compiled = compileRules(active2);
+  return function defaultStyleRedactor(event) {
+    const attributes = walkObject(event.attributes, compiled);
+    const context = walkContext2(event.context, compiled);
+    const message = applyShapeRules(event.message, compiled.shapeRules);
+    let error = event.error;
+    if (event.error !== void 0) {
+      const escName = applyShapeRules(event.error.name, compiled.shapeRules);
+      const escMessage = applyShapeRules(event.error.message, compiled.shapeRules);
+      const stack = event.error.stack;
+      const escStack = stack === void 0 ? void 0 : applyShapeRules(stack, compiled.shapeRules);
+      const errorChanged = escName !== event.error.name || escMessage !== event.error.message || escStack !== stack;
+      if (errorChanged) {
+        error = { name: escName, message: escMessage };
+        if (escStack !== void 0) error.stack = escStack;
+      }
+    }
+    const noChange = attributes === event.attributes && context === event.context && message === event.message && error === event.error;
+    if (noChange) return event;
+    const next = {
+      timestamp: event.timestamp,
+      level: event.level,
+      message,
+      attributes,
+      context
+    };
+    if (error !== void 0) next.error = error;
+    return next;
+  };
+}
+var cachedDefaultRedactor = null;
+function getDefaultRedactor() {
+  if (cachedDefaultRedactor === null) {
+    cachedDefaultRedactor = createRedactor();
+  }
+  return cachedDefaultRedactor;
+}
+var redact = (event, config) => {
+  const redactor = config.redactor ?? getDefaultRedactor();
+  const result = redactor(event);
+  if (result === null) return null;
+  if (!isLogEventShape(result)) {
+    throw new PackageError(
+      "redactor_failed",
+      "Redactor returned a value that is neither a LogEvent nor null; the event is dropped (fail-closed)."
+    );
+  }
+  return result;
+};
+function walkObject(attrs, rules) {
+  let changed = false;
+  let result = null;
+  for (const key of Object.keys(attrs)) {
+    const value = attrs[key];
+    if (value === void 0) continue;
+    const newValue = redactValueAtKey(value, key, rules);
+    if (newValue !== value) {
+      if (result === null) {
+        result = {};
+        for (const k of Object.keys(attrs)) {
+          const existing = attrs[k];
+          if (existing !== void 0) result[k] = existing;
+        }
+      }
+      result[key] = newValue;
+      changed = true;
+    }
+  }
+  return changed && result !== null ? result : attrs;
+}
+function walkContext2(context, rules) {
+  if (context.attributes === void 0) return context;
+  const next = walkObject(context.attributes, rules);
+  if (next === context.attributes) return context;
+  return { ...context, attributes: next };
+}
+function redactValueAtKey(value, key, rules) {
+  for (const rule of rules.keyRules) {
+    if (rule.match(key)) return rule.replacement;
+  }
+  if (typeof value === "string") {
+    return applyShapeRules(value, rules.shapeRules);
+  }
+  if (Array.isArray(value)) {
+    return walkArray2(value, rules);
+  }
+  if (value !== null && typeof value === "object") {
+    return walkObject(value, rules);
+  }
+  return value;
+}
+function walkArray2(arr, rules) {
+  let changed = false;
+  let result = null;
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (item === void 0) continue;
+    let newItem;
+    if (typeof item === "string") {
+      newItem = applyShapeRules(item, rules.shapeRules);
+    } else if (Array.isArray(item)) {
+      newItem = walkArray2(item, rules);
+    } else if (item !== null && typeof item === "object") {
+      newItem = walkObject(item, rules);
+    } else {
+      newItem = item;
+    }
+    if (newItem !== item) {
+      if (result === null) result = arr.slice();
+      result[i] = newItem;
+      changed = true;
+    }
+  }
+  return changed && result !== null ? result : arr;
+}
+function applyShapeRules(value, rules) {
+  for (const rule of rules) {
+    if (rule.pattern.test(value)) return rule.replacement;
+  }
+  return value;
+}
+var VALID_LEVELS = /* @__PURE__ */ new Set([
+  "debug",
+  "info",
+  "warn",
+  "error"
+]);
+function isLogEventShape(value) {
+  if (typeof value !== "object" || /* v8 ignore next */
+  value === null) {
+    return false;
+  }
+  const obj = value;
+  if (typeof obj["timestamp"] !== "string") return false;
+  if (typeof obj["level"] !== "string") return false;
+  if (!VALID_LEVELS.has(obj["level"])) return false;
+  if (typeof obj["message"] !== "string") return false;
+  if (obj["attributes"] === null || typeof obj["attributes"] !== "object") return false;
+  if (obj["context"] === null || typeof obj["context"] !== "object") return false;
+  return true;
+}
+
+// src/pipeline/sanitizer.ts
+var TRUNCATION_MARKER_KEY = "__truncated__";
+var STRING_TRUNCATION_SUFFIX = "...[truncated]";
+var UNSERIALIZABLE_MARKER = "[Unserializable]";
+var sanitize = (event, config) => {
+  const ctx = newContext(config);
+  const sanitizedAttributes = sanitizeRootObject(event.attributes, ctx);
+  const sanitizedContext = sanitizeContext(event.context, ctx);
+  const next = {
+    timestamp: event.timestamp,
+    level: event.level,
+    message: truncateString(event.message, ctx.maxStringLength),
+    attributes: sanitizedAttributes,
+    context: sanitizedContext
+  };
+  if (event.error !== void 0) {
+    next.error = sanitizeErrorInfo(event.error, ctx);
+  }
+  if (ctx.keysOmitted > 0) {
+    next.attributes = withTruncationMarker(next.attributes, ctx.keysOmitted);
+  }
+  return next;
+};
+function newContext(config) {
+  const limits = config.sanitizerLimits;
+  return {
+    maxDepth: limits.maxDepth,
+    maxStringLength: limits.maxStringLength,
+    maxArrayLength: limits.maxArrayLength,
+    maxAttributeCount: limits.maxAttributeCount,
+    keysUsed: 0,
+    keysOmitted: 0,
+    seen: /* @__PURE__ */ new WeakSet()
+  };
+}
+function sanitizeRootObject(source, ctx) {
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return {};
+  }
+  return sanitizeObject(source, 0, ctx);
+}
+function sanitizeContext(source, ctx) {
+  if (source.attributes === void 0) return source;
+  const sanitizedAttrs = sanitizeRootObject(source.attributes, ctx);
+  return { ...source, attributes: sanitizedAttrs };
+}
+function sanitizeErrorInfo(error, ctx) {
+  const info = {
+    name: truncateString(error.name, ctx.maxStringLength),
+    message: truncateString(error.message, ctx.maxStringLength)
+  };
+  if (error.stack !== void 0) {
+    info.stack = truncateString(error.stack, ctx.maxStringLength);
+  }
+  return info;
+}
+function withTruncationMarker(attrs, omitted) {
+  const tagged = { ...attrs };
+  tagged[TRUNCATION_MARKER_KEY] = `[Truncated: ${String(omitted)} keys omitted]`;
+  return tagged;
+}
+function truncateString(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return value.slice(0, maxLength) + STRING_TRUNCATION_SUFFIX;
+}
+function sanitizeValue(value, depth, ctx) {
+  try {
+    return sanitizeValueImpl(value, depth, ctx);
+  } catch {
+    return UNSERIALIZABLE_MARKER;
+  }
+}
+function sanitizeValueImpl(value, depth, ctx) {
+  if (depth > ctx.maxDepth) return "[MaxDepth]";
+  if (value === null) return null;
+  const t = typeof value;
+  if (t === "string") return truncateString(value, ctx.maxStringLength);
+  if (t === "number") {
+    const n = value;
+    return Number.isFinite(n) ? n : null;
+  }
+  if (t === "boolean") return value;
+  if (t === "bigint") return String(value);
+  if (t === "function") return "[Function]";
+  if (t === "symbol") return "[Symbol]";
+  if (t === "undefined") return null;
+  const obj = value;
+  if (ctx.seen.has(obj)) return "[Circular]";
+  if (Array.isArray(value)) {
+    return sanitizeArray(value, depth, ctx);
+  }
+  if (value instanceof Date) {
+    return dateToIso(value);
+  }
+  if (value instanceof Error) {
+    return sanitizeErrorAsAttribute(value, depth, ctx);
+  }
+  if (typeof Element !== "undefined" && value instanceof Element) {
+    return `[Element:${tagNameOf(value)}]`;
+  }
+  if (typeof Document !== "undefined" && value instanceof Document) {
+    return "[Document]";
+  }
+  if (typeof Window !== "undefined" && value instanceof Window) {
+    return "[Window]";
+  }
+  if (typeof Node !== "undefined" && value instanceof Node) {
+    return "[Node]";
+  }
+  if (typeof Event !== "undefined" && value instanceof Event) {
+    return `[Event:${eventTypeOf(value)}]`;
+  }
+  if (typeof Promise !== "undefined" && value instanceof Promise) {
+    return "[Promise]";
+  }
+  if (typeof Map !== "undefined" && value instanceof Map) {
+    return "[Map]";
+  }
+  if (typeof Set !== "undefined" && value instanceof Set) {
+    return "[Set]";
+  }
+  if (typeof WeakMap !== "undefined" && value instanceof WeakMap) {
+    return "[WeakMap]";
+  }
+  if (typeof WeakSet !== "undefined" && value instanceof WeakSet) {
+    return "[WeakSet]";
+  }
+  if (typeof Request !== "undefined" && value instanceof Request) {
+    return "[Request]";
+  }
+  if (typeof Response !== "undefined" && value instanceof Response) {
+    return "[Response]";
+  }
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    return "[Blob]";
+  }
+  if (typeof FormData !== "undefined" && value instanceof FormData) {
+    return "[FormData]";
+  }
+  if (typeof URL !== "undefined" && value instanceof URL) {
+    return "[URL]";
+  }
+  if (isPlainObject(obj)) {
+    return sanitizeObject(obj, depth, ctx);
+  }
+  return `[${getConstructorName(obj)}]`;
+}
+function sanitizeArray(arr, depth, ctx) {
+  ctx.seen.add(arr);
+  const out = [];
+  const len = arr.length;
+  const limit = len > ctx.maxArrayLength ? ctx.maxArrayLength : len;
+  for (let i = 0; i < limit; i++) {
+    out.push(sanitizeValue(arr[i], depth + 1, ctx));
+  }
+  if (len > ctx.maxArrayLength) {
+    const omitted = len - ctx.maxArrayLength;
+    out.push(`[Truncated: ${String(omitted)} elements omitted]`);
+  }
+  ctx.seen.delete(arr);
+  return out;
+}
+function sanitizeObject(obj, depth, ctx) {
+  ctx.seen.add(obj);
+  const result = {};
+  const keys = ownEnumerableKeys(obj);
+  for (const key of keys) {
+    const raw = readProperty(obj, key);
+    if (raw === void 0) continue;
+    if (ctx.keysUsed >= ctx.maxAttributeCount) {
+      ctx.keysOmitted++;
+      continue;
+    }
+    ctx.keysUsed++;
+    result[key] = sanitizeValue(raw, depth + 1, ctx);
+  }
+  ctx.seen.delete(obj);
+  return result;
+}
+function sanitizeErrorAsAttribute(err, depth, ctx) {
+  const reduced = {
+    name: safeString(() => err.name, "Error"),
+    message: safeString(() => err.message, "")
+  };
+  const stack = safeOptional(() => err.stack);
+  if (stack !== void 0) {
+    reduced["stack"] = stack;
+  }
+  return sanitizeObject(reduced, depth, ctx);
+}
+function ownEnumerableKeys(obj) {
+  try {
+    return Object.keys(obj);
+  } catch {
+    return [];
+  }
+}
+function readProperty(obj, key) {
+  try {
+    return obj[key];
+  } catch {
+    return UNSERIALIZABLE_MARKER;
+  }
+}
+function isPlainObject(obj) {
+  const proto = Object.getPrototypeOf(obj);
+  return proto === null || proto === Object.prototype;
+}
+function getConstructorName(obj) {
+  try {
+    const proto = Object.getPrototypeOf(obj);
+    const ctor = proto?.constructor;
+    const name = ctor?.name;
+    if (typeof name === "string" && name.length > 0) return name;
+  } catch {
+  }
+  return "Object";
+}
+function tagNameOf(el) {
+  try {
+    const t = el.tagName;
+    return typeof t === "string" && t.length > 0 ? t.toLowerCase() : "element";
+  } catch {
+    return "element";
+  }
+}
+function eventTypeOf(ev) {
+  try {
+    const t = ev.type;
+    return typeof t === "string" && t.length > 0 ? t : "event";
+  } catch {
+    return "event";
+  }
+}
+function dateToIso(d) {
+  try {
+    return d.toISOString();
+  } catch {
+    return null;
+  }
+}
+function safeString(read, fallback) {
+  try {
+    const v = read();
+    return typeof v === "string" ? v : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function safeOptional(read) {
+  try {
+    const v = read();
+    return typeof v === "string" ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/pipeline/url-scrubber.ts
+var REDACTED = "[REDACTED]";
+var DEFAULT_PARAM_DENYLIST = [
+  /^password$/i,
+  /^passwd$/i,
+  /^token$/i,
+  /access[_-]?token/i,
+  /refresh[_-]?token/i,
+  /bearer[_-]?token/i,
+  /id[_-]?token/i,
+  /^authorization$/i,
+  /^auth$/i,
+  /^cookie$/i,
+  /^set-cookie$/i,
+  /^secret$/i,
+  /client[_-]?secret/i,
+  /api[_-]?key/i,
+  /session[_-]?id/i,
+  /^sid$/i,
+  /^ssn$/i,
+  /credit[_-]?card/i,
+  /^cardnumber$/i,
+  /^cvv$/i
+];
+function scrubUrl(url, options) {
+  if (typeof url !== "string" || url.length === 0) return url;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return url;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return url;
+  }
+  const extras = options?.extraParams ?? [];
+  const scrubFragment = options?.fragment !== false;
+  let changed = false;
+  changed = scrubSearchParams(parsed, extras) || changed;
+  if (scrubFragment) {
+    changed = scrubHashFragment(parsed, extras) || changed;
+  }
+  if (!changed) return url;
+  return parsed.toString();
+}
+var urlScrub = (event, _config) => {
+  const message = maybeScrubString(event.message);
+  const attributes = walkAttributes2(event.attributes);
+  const context = walkContext3(event.context);
+  let error = void 0;
+  if (event.error !== void 0) {
+    const scrubbedMessage = maybeScrubString(event.error.message);
+    const stack = event.error.stack;
+    const scrubbedStack = stack === void 0 ? void 0 : maybeScrubString(stack);
+    error = { name: event.error.name, message: scrubbedMessage };
+    if (scrubbedStack !== void 0) error.stack = scrubbedStack;
+  }
+  const noChange = message === event.message && attributes === event.attributes && context === event.context && error === event.error;
+  if (noChange) return event;
+  const next = {
+    timestamp: event.timestamp,
+    level: event.level,
+    message,
+    attributes,
+    context
+  };
+  if (error !== void 0) next.error = error;
+  return next;
+};
+function scrubSearchParams(parsed, extras) {
+  const entries = [];
+  for (const [name, value] of parsed.searchParams.entries()) {
+    entries.push([name, value]);
+  }
+  let changed = false;
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (isDenied(entry[0], extras)) {
+      entries[i] = [entry[0], REDACTED];
+      changed = true;
+    }
+  }
+  if (!changed) return false;
+  const uniqueKeys = /* @__PURE__ */ new Set();
+  for (const entry of entries) uniqueKeys.add(entry[0]);
+  for (const key of uniqueKeys) parsed.searchParams.delete(key);
+  for (const [name, value] of entries) parsed.searchParams.append(name, value);
+  return true;
+}
+function scrubHashFragment(parsed, extras) {
+  const hash = parsed.hash;
+  if (hash.length < 2 || !hash.startsWith("#")) return false;
+  const body = hash.slice(1);
+  if (!body.includes("=")) return false;
+  const parts = body.split("&");
+  let changed = false;
+  const out = [];
+  for (const part of parts) {
+    const eq = part.indexOf("=");
+    if (eq < 0) {
+      out.push(part);
+      continue;
+    }
+    const rawKey = part.slice(0, eq);
+    const decodedKey = tryDecode(rawKey);
+    if (isDenied(decodedKey, extras)) {
+      out.push(`${rawKey}=${encodeURIComponent(REDACTED)}`);
+      changed = true;
+    } else {
+      out.push(part);
+    }
+  }
+  if (!changed) return false;
+  parsed.hash = "#" + out.join("&");
+  return true;
+}
+function isDenied(name, extras) {
+  for (const pattern of DEFAULT_PARAM_DENYLIST) {
+    if (pattern.test(name)) return true;
+  }
+  for (const pattern of extras) {
+    if (typeof pattern === "string") {
+      if (pattern.toLowerCase() === name.toLowerCase()) return true;
+    } else if (pattern.test(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+function tryDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function maybeScrubString(value) {
+  if (value.length < 8) return value;
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    return scrubUrl(value);
+  }
+  return value;
+}
+function walkAttributes2(attrs) {
+  let changed = false;
+  let result = null;
+  for (const key of Object.keys(attrs)) {
+    const value = attrs[key];
+    if (value === void 0) continue;
+    const scrubbed = walkValue2(value);
+    if (scrubbed !== value) {
+      if (result === null) {
+        result = {};
+        for (const k of Object.keys(attrs)) {
+          const existing = attrs[k];
+          if (existing !== void 0) result[k] = existing;
+        }
+      }
+      result[key] = scrubbed;
+      changed = true;
+    }
+  }
+  return changed && result !== null ? result : attrs;
+}
+function walkValue2(value) {
+  if (typeof value === "string") return maybeScrubString(value);
+  if (Array.isArray(value)) return walkArray3(value);
+  if (value !== null && typeof value === "object") return walkAttributes2(value);
+  return value;
+}
+function walkArray3(arr) {
+  let changed = false;
+  let result = null;
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (item === void 0) continue;
+    const scrubbed = walkValue2(item);
+    if (scrubbed !== item) {
+      if (result === null) result = arr.slice();
+      result[i] = scrubbed;
+      changed = true;
+    }
+  }
+  return changed && result !== null ? result : arr;
+}
+function walkContext3(context) {
+  if (context.attributes === void 0) return context;
+  const scrubbed = walkAttributes2(context.attributes);
+  if (scrubbed === context.attributes) return context;
+  return { ...context, attributes: scrubbed };
+}
+
+// src/pipeline/dispatcher.ts
+function dispatch(event, config) {
+  let current;
+  try {
+    current = sanitize(event, config);
+    if (current === null) return;
+    current = urlScrub(current, config);
+    if (current === null) return;
+    current = redact(current, config);
+    if (current === null) return;
+    current = controlCharGuard(current, config);
+    if (current === null) return;
+    current = freezeInDev(current, config);
+    if (current === null) return;
+  } catch (err) {
+    safeNotify(
+      config.onInternalError,
+      wrapAsPackageError(
+        "redactor_failed",
+        "A pipeline stage threw; the event was dropped (fail-closed).",
+        err
+      )
+    );
+    return;
+  }
+  for (const transport of config.transports) {
+    try {
+      const result = transport.send(current);
+      if (result instanceof Promise) {
+        result.then(void 0, () => void 0);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/pipeline/event-builder.ts
+function buildLogEvent(input) {
+  const event = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level: input.level,
+    message: input.message,
+    attributes: input.attributes ?? {},
+    context: input.context
+  };
+  if (input.errorValue !== void 0) {
+    event.error = reduceError(input.errorValue);
+  }
+  return event;
+}
+function reduceError(value) {
+  if (value instanceof Error) {
+    const info = { name: value.name, message: value.message };
+    if (value.stack !== void 0) info.stack = value.stack;
+    return info;
+  }
+  return { name: "NonError", message: String(value) };
+}
+
+// src/pipeline/level-filter.ts
+var LEVEL_NUMBER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function resolveEffectiveLevel(perLoggerLevel, configLevel) {
+  return perLoggerLevel ?? configLevel;
+}
+function passesLevelFilter(eventLevel, perLoggerLevel, configLevel) {
+  const effective = resolveEffectiveLevel(perLoggerLevel, configLevel);
+  return LEVEL_NUMBER[eventLevel] >= LEVEL_NUMBER[effective];
+}
+
+// src/config/env-defaults.ts
+var DEFAULT_LEVEL_BY_ENVIRONMENT = {
+  production: "warn",
+  development: "debug",
+  test: "warn"
+};
+var FALLBACK_LEVEL = "warn";
+var DEFAULT_SANITIZER_LIMITS = {
+  maxDepth: 8,
+  maxStringLength: 8192,
+  maxArrayLength: 1e3,
+  maxAttributeCount: 256
+};
+var SANITIZER_LIMIT_BOUNDS = {
+  maxDepth: { min: 1, max: 16 },
+  maxStringLength: { min: 64, max: 65536 },
+  maxArrayLength: { min: 1, max: 1e4 },
+  maxAttributeCount: { min: 1, max: 4096 }
+};
+function defaultLevelForEnvironment(environment) {
+  if (environment === void 0) return FALLBACK_LEVEL;
+  return DEFAULT_LEVEL_BY_ENVIRONMENT[environment] ?? FALLBACK_LEVEL;
+}
+
+// src/config/config.ts
+var NOOP_ON_INTERNAL_ERROR = () => void 0;
+function normalizeConfig(config) {
+  const environment = config.environment;
+  const onInternalError = config.onInternalError ?? NOOP_ON_INTERNAL_ERROR;
+  const sanitizerLimits = resolveSanitizerLimits(
+    config.sanitizerLimits,
+    onInternalError
+  );
+  const level = resolveConfigLevel(config.level, environment);
+  const transports = (config.transports ?? []).map(
+    (entry) => typeof entry === "function" ? entry() : entry
+  );
+  return {
+    application: config.application,
+    module: config.module,
+    environment,
+    level,
+    context: config.context ?? {},
+    correlation: config.correlation,
+    transports,
+    redactor: config.redactor,
+    sanitizerLimits,
+    onInternalError
+  };
+}
+function resolveConfigLevel(level, environment) {
+  if (level === void 0) {
+    return defaultLevelForEnvironment(environment);
+  }
+  if (typeof level === "string") {
+    return level;
+  }
+  if (environment !== void 0) {
+    const map = level;
+    const mapped = map[environment];
+    if (mapped !== void 0) return mapped;
+  }
+  return defaultLevelForEnvironment(environment);
+}
+function resolveSanitizerLimits(overrides, onInternalError) {
+  if (overrides === void 0) {
+    return { ...DEFAULT_SANITIZER_LIMITS };
+  }
+  const limits = { ...DEFAULT_SANITIZER_LIMITS };
+  const keys = Object.keys(SANITIZER_LIMIT_BOUNDS);
+  for (const key of keys) {
+    const requested = overrides[key];
+    if (requested === void 0) continue;
+    const bounds = SANITIZER_LIMIT_BOUNDS[key];
+    if (requested > bounds.max) {
+      limits[key] = bounds.max;
+      safeNotify(
+        onInternalError,
+        new PackageError(
+          "sanitizer_limit_clamped",
+          `sanitizerLimits.${key} value ${String(requested)} exceeds max ${String(bounds.max)}; clamped to ${String(bounds.max)}`
+        )
+      );
+    } else if (requested < bounds.min) {
+      limits[key] = bounds.min;
+      safeNotify(
+        onInternalError,
+        new PackageError(
+          "sanitizer_limit_clamped",
+          `sanitizerLimits.${key} value ${String(requested)} is below min ${String(bounds.min)}; clamped to ${String(bounds.min)}`
+        )
+      );
+    } else {
+      limits[key] = requested;
+    }
+  }
+  return limits;
+}
+
+// src/transport/noop-transport.ts
+var NoopTransport = () => ({
+  name: "noop",
+  send() {
+  }
+});
+
+// src/transport/safe-transport.ts
+var SafeTransport = class {
+  constructor(inner, onInternalError) {
+    this.notified = false;
+    this.inner = inner;
+    this.name = inner.name;
+    this.onInternalError = onInternalError;
+  }
+  send(event) {
+    try {
+      const result = this.inner.send(event);
+      if (result instanceof Promise) {
+        result.then(void 0, (reason) => {
+          this.notify(reason, "transport_send_failed");
+        });
+      }
+    } catch (err) {
+      this.notify(err, "transport_send_failed");
+    }
+  }
+  async flush() {
+    if (this.inner.flush === void 0) return;
+    try {
+      await this.inner.flush();
+    } catch (err) {
+      this.notify(err, "transport_send_failed");
+    }
+  }
+  async shutdown() {
+    if (this.inner.shutdown === void 0) return;
+    try {
+      await this.inner.shutdown();
+    } catch (err) {
+      this.notify(err, "transport_shutdown_failed");
+    }
+  }
+  notify(cause, code) {
+    if (this.notified) return;
+    this.notified = true;
+    safeNotify(
+      this.onInternalError,
+      wrapAsPackageError(
+        code,
+        `Transport '${this.name}' failed: ${describe(cause)}`,
+        cause,
+        this.name
+      )
+    );
+  }
+};
+function describe(value) {
+  if (value instanceof Error) return value.message;
+  if (typeof value === "string") return value;
+  return String(value);
+}
+
+// src/runtime/configured-runtime.ts
+function buildConfiguredRuntime(config) {
+  const normalized = normalizeConfig(config);
+  const sourceTransports = normalized.transports.length === 0 ? [NoopTransport()] : normalized.transports;
+  const wrapped = sourceTransports.map(
+    (t) => new SafeTransport(t, normalized.onInternalError)
+  );
+  const installedConfig = {
+    ...normalized,
+    transports: wrapped
+  };
+  return {
+    config: installedConfig,
+    transports: wrapped,
+    redactor: normalized.redactor,
+    sanitizerLimits: normalized.sanitizerLimits,
+    onInternalError: normalized.onInternalError,
+    correlation: normalized.correlation
+  };
+}
+async function shutdownRuntime(runtime) {
+  for (const transport of runtime.transports) {
+    if (transport.flush !== void 0) {
+      try {
+        await transport.flush();
+      } catch {
+      }
+    }
+    if (transport.shutdown !== void 0) {
+      try {
+        await transport.shutdown();
+      } catch {
+      }
+    }
+  }
+}
+
+// src/runtime/runtime-ref.ts
+var active;
+function getActiveRuntime() {
+  return active;
+}
+function installRuntime(runtime) {
+  const previous = active;
+  active = runtime;
+  return previous;
+}
+
+// src/api/logger.ts
+var rootLogger;
+function installState(config) {
+  const runtime = buildConfiguredRuntime(config);
+  const previousRuntime = installRuntime(runtime);
+  if (previousRuntime !== void 0) {
+    void shutdownRuntime(previousRuntime).then(void 0, () => void 0);
+  }
+  return runtime;
+}
+function ensureState() {
+  let runtime = getActiveRuntime();
+  if (runtime === void 0) {
+    runtime = installState({});
+  }
+  return runtime;
+}
+function configureLogging(config) {
+  installState(config);
+}
+function createLogger(options = {}) {
+  return makeLogger(options, []);
+}
+function getRootLogger() {
+  if (rootLogger === void 0) {
+    rootLogger = createLogger();
+  }
+  return rootLogger;
+}
+function makeLogger(options, chainedContexts) {
+  const loggerContextLayers = [
+    options.context ?? {},
+    options.module !== void 0 ? { module: options.module } : {}
+  ];
+  function emit(level, message, attributes, errorValue) {
+    const runtime = ensureState();
+    const cfg = runtime.config;
+    if (!passesLevelFilter(level, options.level, cfg.level)) {
+      return;
+    }
+    const rootIdentity = {};
+    if (cfg.application !== void 0) {
+      rootIdentity.application = cfg.application;
+    }
+    if (cfg.module !== void 0) {
+      rootIdentity.module = cfg.module;
+    }
+    if (cfg.environment !== void 0) {
+      rootIdentity.environment = cfg.environment;
+    }
+    let correlation;
+    if (cfg.correlation !== void 0) {
+      try {
+        correlation = cfg.correlation();
+      } catch (err) {
+        safeNotify(
+          cfg.onInternalError,
+          wrapAsPackageError(
+            "correlation_failed",
+            "correlation() callback threw; its output is dropped for this event.",
+            err
+          )
+        );
+      }
+    }
+    const context = mergeContexts(
+      rootIdentity,
+      cfg.context,
+      ...loggerContextLayers,
+      ...chainedContexts,
+      correlation
+    );
+    const event = buildLogEvent({
+      level,
+      message,
+      attributes,
+      context,
+      errorValue
+    });
+    dispatch(event, cfg);
+  }
+  return {
+    debug(message, attributes) {
+      emit("debug", message, attributes);
+    },
+    info(message, attributes) {
+      emit("info", message, attributes);
+    },
+    warn(message, attributes) {
+      emit("warn", message, attributes);
+    },
+    error(message, attributes, errorValue) {
+      emit("error", message, attributes, errorValue);
+    },
+    child(context) {
+      return makeLogger(options, [...chainedContexts, context]);
+    },
+    withContext(context) {
+      return makeLogger(options, [...chainedContexts, context]);
+    }
+  };
+}
+
+// src/transport/console-transport.ts
+function resolveConsoleMethod(level) {
+  const slot = console[level];
+  if (typeof slot === "function") {
+    return slot.bind(console);
+  }
+  return console.log.bind(console);
+}
+var ConsoleTransport = () => ({
+  name: "console",
+  send(event) {
+    const log = resolveConsoleMethod(event.level);
+    log(event.message, event);
+  }
+});
+
+export { ConsoleTransport, NoopTransport, configureLogging, createLogger, createRedactor, getRootLogger, scrubUrl };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map