@autter/runtime-node 1.3.4 → 1.5.0

package/dist/chunk-P4VRTFAV.cjs

@@ -0,0 +1,1680 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkGI47WGRRcjs = require('./chunk-GI47WGRR.cjs');
+
+// ../runtime-core/dist/index.js
+var SENSITIVE_KEY_PATTERNS = [
+  /e-?mail/,
+  /pass(word|wd|phrase)|^pass$|(^|[._-])pwd$/,
+  /token/,
+  /secret/,
+  /credential/,
+  /(api|access|secret|private|consumer|client|signing|encryption)-?[_.]?key/,
+  /authori[sz]ation|^auth(-|_|$)|bearer/,
+  /cookie/,
+  /(^|[._-])session$|^(j|php)?sess(ion)?id$|^sid$|connect\.sid/,
+  /phone|msisdn/,
+  /(^|[^a-z])ssn($|[^a-z])|social[-_ ]?security/,
+  /cvv|cvc|(^|[^a-z])card([-_. ]?(number|num|no))?$/,
+  /credit[-_.]?card/,
+  /connection[-_.]?string|(^|[._-])dsn$/,
+  /recovery[-_.]?code|\botp\b|magic[-_.]?link/
+];
+var PRIVATE_KEY_BLOCK_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g;
+var PREFIXED_SECRET_RE = /\b(?:sk-[A-Za-z0-9_-]{20,}|(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{10,}|whsec_[A-Za-z0-9]{10,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|glpat-[A-Za-z0-9_-]{20,}|xox[abposr]-[A-Za-z0-9-]{10,}|AIza[A-Za-z0-9_-]{30,}|(?:AKIA|ASIA)[0-9A-Z]{16}|npm_[A-Za-z0-9]{36}|autter_(?:rt|pat)_[A-Za-z0-9_-]{10,}|SG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,})/g;
+var JWT_RE = /(?<![A-Za-z0-9_-])eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g;
+var AUTH_SCHEME_RE = /\b(?:bearer\s+[A-Za-z0-9._~+/=-]{10,}|basic\s+(?=[A-Za-z0-9+/]*[0-9+/=])[A-Za-z0-9+/]{8,}={0,2})/gi;
+var HEADER_VALUE_RE = /((?:^|[^\w-])(?:proxy-)?(?:authorization|(?:set-)?cookie)["']?\s*[:=]\s*["']?)[^"'\r\n]+/gim;
+var SECRET_ASSIGNMENT_RE = /(password|passwd|pwd|passphrase|secret|token|api[_-]?key|apikey|access[_-]?key|private[_-]?key|credential|signature|session[_-]?id|sessionid|ssn)(["']?\s*[:=]\s*)("[^"\r\n]*"|'[^'\r\n]*'|[^\s"'&,;)}\]\[<>]+)/gi;
+var URL_CREDENTIALS_RE = /\b([a-z][a-z0-9+.-]{0,31}:\/\/)(?:[^\s/:@"'<>]*:[^\s/"'<>]*|[^\s/:@"'<>]{16,})@/gi;
+var CARD_RE = /\b(?:4\d{3}|5[1-5]\d{2}|2[2-7]\d{2}|3[47]\d{2}|6(?:011|5\d{2}))(?:[ -]?\d){9,15}\b/g;
+var EMAIL_VALUE_RE = /[A-Z0-9._%+-]{1,64}@[A-Z0-9.-]{1,253}\.[A-Z]{2,63}/gi;
+function luhnValid(candidate) {
+  const digits = candidate.replace(/\D/g, "");
+  if (digits.length < 13 || digits.length > 19) return false;
+  let sum = 0;
+  for (let i = 0; i < digits.length; i++) {
+    let d = digits.charCodeAt(digits.length - 1 - i) - 48;
+    if (i % 2 === 1) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+  }
+  return sum % 10 === 0;
+}
+function toCaseInsensitive(pattern) {
+  if (typeof pattern === "string")
+    return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+  const flags = pattern.flags.replace(/[gyi]/g, "");
+  return new RegExp(pattern.source, `${flags}i`);
+}
+function toGlobal(pattern) {
+  if (typeof pattern === "string") return new RegExp(pattern, "gi");
+  return new RegExp(pattern.source, `${pattern.flags.replace(/[gy]/g, "")}g`);
+}
+function compile(options) {
+  const keyPatterns = [...SENSITIVE_KEY_PATTERNS];
+  const extraValuePatterns = [];
+  for (const p of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.additionalKeyPatterns]), () => ( []))) {
+    keyPatterns.push(toCaseInsensitive(p));
+  }
+  for (const p of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.additionalValuePatterns]), () => ( []))) {
+    const re = toGlobal(p);
+    if (!extraValuePatterns.some((existing) => existing.source === re.source)) {
+      extraValuePatterns.push(re);
+    }
+  }
+  return {
+    keyPatterns,
+    extraValuePatterns,
+    mask: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.mask]), () => ( "[redacted]")),
+    scrubEmailValues: _optionalChain([options, 'optionalAccess', _4 => _4.scrubEmailValues]) !== false,
+    scrubCardNumbers: _optionalChain([options, 'optionalAccess', _5 => _5.scrubCardNumbers]) !== false
+  };
+}
+var MAX_SCRUB_CHARS = 64 * 1024;
+function redactString(value, r) {
+  const mask = r.mask;
+  let out = value.length > MAX_SCRUB_CHARS ? value.slice(0, MAX_SCRUB_CHARS) : value;
+  out = out.replace(PRIVATE_KEY_BLOCK_RE, mask).replace(PREFIXED_SECRET_RE, mask).replace(JWT_RE, mask).replace(AUTH_SCHEME_RE, mask).replace(HEADER_VALUE_RE, (_m, head) => head + mask).replace(
+    SECRET_ASSIGNMENT_RE,
+    (_m, key, sep, val) => key + sep + (val[0] === '"' || val[0] === "'" ? val[0] + mask + val[0] : mask)
+  ).replace(URL_CREDENTIALS_RE, (_m, scheme) => `${scheme}${mask}@`);
+  if (r.scrubCardNumbers) {
+    out = out.replace(CARD_RE, (m) => luhnValid(m) ? mask : m);
+  }
+  if (r.scrubEmailValues) {
+    out = out.replace(EMAIL_VALUE_RE, mask);
+  }
+  for (const re of r.extraValuePatterns) {
+    re.lastIndex = 0;
+    out = out.replace(re, mask);
+  }
+  return out;
+}
+var MAX_REDACTION_DEPTH = 64;
+var MAX_REDACTION_WORK = 1e4;
+var MAX_COLLECTION_ENTRIES = 1e3;
+function canTraverse(depth, state) {
+  if (depth > MAX_REDACTION_DEPTH || state.remainingWork <= 0) return false;
+  state.remainingWork -= 1;
+  return true;
+}
+function redactValue(value, r, state, depth) {
+  if (typeof value === "string") return redactString(value, r);
+  let isArray = false;
+  try {
+    isArray = Array.isArray(value);
+  } catch (e2) {
+    return r.mask;
+  }
+  if (isArray) {
+    return redactArray(value, r, state, depth);
+  }
+  if (typeof value === "object" && value !== null) {
+    return redactObject(value, r, state, depth);
+  }
+  return value;
+}
+function redactArray(value, r, state, depth) {
+  const existing = state.ancestors.get(value);
+  if (existing) return r.mask;
+  if (!canTraverse(depth, state)) return r.mask;
+  const out = [];
+  state.ancestors.set(value, out);
+  let length;
+  try {
+    length = value.length;
+  } catch (e3) {
+    state.ancestors.delete(value);
+    return r.mask;
+  }
+  const limit = Math.min(length, MAX_COLLECTION_ENTRIES);
+  for (let i = 0; i < limit; i += 1) {
+    let item;
+    try {
+      item = value[i];
+    } catch (e4) {
+      out.push(r.mask);
+      continue;
+    }
+    out.push(redactValue(item, r, state, depth + 1));
+  }
+  if (length > limit) {
+    out.push(r.mask);
+  }
+  state.ancestors.delete(value);
+  return out;
+}
+function redactObject(value, r, state, depth) {
+  const existing = state.ancestors.get(value);
+  if (existing) return r.mask;
+  if (!canTraverse(depth, state)) return r.mask;
+  const out = {};
+  state.ancestors.set(value, out);
+  let count = 0;
+  let truncated = false;
+  try {
+    for (const key in value) {
+      if (!Object.prototype.propertyIsEnumerable.call(
+        value,
+        key
+      )) {
+        continue;
+      }
+      if (count >= MAX_COLLECTION_ENTRIES) {
+        truncated = true;
+        break;
+      }
+      let nestedValue;
+      try {
+        nestedValue = value[key];
+      } catch (e5) {
+        out[key] = r.mask;
+        count += 1;
+        continue;
+      }
+      count += 1;
+      out[key] = isSensitiveKey(key, nestedValue, r) ? r.mask : redactValue(
+        nestedValue,
+        r,
+        state,
+        depth + 1
+      );
+    }
+  } catch (e6) {
+    truncated = true;
+  }
+  if (truncated) {
+    out.__redaction_truncated__ = r.mask;
+  }
+  state.ancestors.delete(value);
+  return out;
+}
+var USAGE_TOKEN_KEYS = /* @__PURE__ */ new Set([
+  "input_tokens",
+  "output_tokens",
+  "prompt_tokens",
+  "completion_tokens",
+  "total_tokens",
+  "token_count",
+  "cache_read_tokens",
+  "cache_creation_tokens",
+  "cache_read_input_tokens",
+  "cache_creation_input_tokens",
+  "cached_tokens",
+  "reasoning_tokens",
+  "gen_ai.usage.input_tokens",
+  "gen_ai.usage.output_tokens",
+  "gen_ai.usage.prompt_tokens",
+  "gen_ai.usage.completion_tokens",
+  "gen_ai.usage.total_tokens",
+  "gen_ai.usage.token_count"
+]);
+function isSensitiveKey(key, value, r) {
+  const lowered = key.toLowerCase();
+  if (USAGE_TOKEN_KEYS.has(lowered)) {
+    return !(typeof value === "number" && Number.isFinite(value) && value >= 0);
+  }
+  return r.keyPatterns.some((re) => re.test(lowered));
+}
+function redactAttributes(attributes, options) {
+  const r = compile(options);
+  return redactWith(attributes, r);
+}
+function redactWith(attributes, r) {
+  const out = {};
+  if (!attributes) return out;
+  const state = {
+    ancestors: /* @__PURE__ */ new WeakMap(),
+    remainingWork: MAX_REDACTION_WORK
+  };
+  let count = 0;
+  let truncated = false;
+  try {
+    for (const key in attributes) {
+      if (!Object.prototype.propertyIsEnumerable.call(
+        attributes,
+        key
+      )) {
+        continue;
+      }
+      if (count >= MAX_COLLECTION_ENTRIES || state.remainingWork <= 0) {
+        truncated = true;
+        break;
+      }
+      let value;
+      try {
+        value = attributes[key];
+      } catch (e7) {
+        out[key] = r.mask;
+        count += 1;
+        state.remainingWork -= 1;
+        continue;
+      }
+      count += 1;
+      state.remainingWork -= 1;
+      if (value === void 0) continue;
+      out[key] = isSensitiveKey(key, value, r) ? r.mask : redactValue(value, r, state, 0);
+    }
+  } catch (e8) {
+    truncated = true;
+  }
+  if (truncated) {
+    out.__redaction_truncated__ = r.mask;
+  }
+  return out;
+}
+function redactText(text, options) {
+  return typeof text === "string" ? redactString(text, compile(options)) : text;
+}
+function makeRedactor(options) {
+  if (options === false) {
+    const passthrough = ((attributes) => ({
+      ..._nullishCoalesce(attributes, () => ( {}))
+    }));
+    passthrough.text = (value) => value;
+    passthrough.exported = (attributes) => attributes;
+    passthrough.enabled = false;
+    return passthrough;
+  }
+  const r = compile(options === true ? void 0 : options);
+  const redactor = ((attributes) => redactWith(attributes, r));
+  redactor.text = (value) => typeof value === "string" ? redactString(value, r) : value;
+  redactor.exported = (attributes) => {
+    const out = {};
+    for (const key of Object.keys(attributes)) {
+      const value = attributes[key];
+      if (typeof value === "string") {
+        out[key] = r.keyPatterns.some((re) => re.test(key.toLowerCase())) ? r.mask : redactString(value, r);
+      } else if (Array.isArray(value)) {
+        const sensitive = r.keyPatterns.some((re) => re.test(key.toLowerCase()));
+        out[key] = value.map(
+          (item) => typeof item === "string" ? sensitive ? r.mask : redactString(item, r) : item
+        );
+      } else {
+        out[key] = value;
+      }
+    }
+    return out;
+  };
+  redactor.enabled = true;
+  return redactor;
+}
+var LEVEL_SEVERITY = {
+  debug: 5,
+  info: 9,
+  warning: 13,
+  error: 17
+};
+function stripUrlQueries(value) {
+  return value.replace(/https?:\/\/[^\s]*/gi, (url) => {
+    const rest = url.slice(url.indexOf("://") + 3);
+    const cut = rest.search(/[?#]/);
+    return cut <= 0 ? url : url.slice(0, url.length - rest.length + cut);
+  });
+}
+function maxLevel(a, b) {
+  return LEVEL_SEVERITY[b] > LEVEL_SEVERITY[a] ? b : a;
+}
+var RESERVED_KEY = /^autter\.(?:operation|event|request|error)\.|^autter\.(?:parent_trace_id|capture\.mode)$/;
+function priority(key) {
+  if (key === "autter.operation.logs") return -1;
+  if (/^autter\.(?:operation|event|request)\.|^autter\.parent_trace_id$/.test(key))
+    return 2;
+  if (/^(?:exception|autter\.error)\./.test(key)) return 1;
+  return 0;
+}
+function boundContext(attributes = {}, redact2) {
+  const redacted = redact2 ? redact2(attributes) : redactAttributes(attributes);
+  let budget = 512;
+  let characters = 16384;
+  let truncated = false;
+  const visit = (input, depth) => {
+    if (--budget < 0 || depth > 6) {
+      truncated = true;
+      return "[truncated]";
+    }
+    if (typeof input === "string") {
+      const text = stripUrlQueries(input);
+      const kept = text.slice(0, Math.max(0, characters));
+      truncated ||= kept.length < text.length;
+      characters -= kept.length;
+      return kept;
+    }
+    if (typeof input === "number")
+      return Number.isFinite(input) ? input : void 0;
+    if (typeof input === "boolean" || input === null) return input;
+    if (Array.isArray(input)) {
+      truncated ||= input.length > 64;
+      return input.slice(0, 64).map((item) => visit(item, depth + 1));
+    }
+    if (input && typeof input === "object") {
+      const entries = Object.entries(input);
+      if (depth === 0) entries.sort(([a], [b]) => priority(b) - priority(a));
+      truncated ||= entries.length > 100;
+      return Object.fromEntries(
+        entries.slice(0, 100).filter(([key]) => !/^(?:__proto__|constructor|prototype)$/.test(key)).map(([key, item]) => [key.slice(0, 200), visit(item, depth + 1)])
+      );
+    }
+    return void 0;
+  };
+  const result = visit(redacted, 0);
+  if (truncated) result["autter.context.truncated"] = true;
+  return result;
+}
+function userContext(attributes = {}, redact2) {
+  return Object.fromEntries(
+    Object.entries(boundContext(attributes, redact2)).filter(
+      ([key]) => !RESERVED_KEY.test(key)
+    )
+  );
+}
+function mergeContext(current, next = {}, redact2) {
+  const merge2 = (left, right, depth) => {
+    const result = { ...left };
+    for (const [key, value] of Object.entries(right)) {
+      const prior = result[key];
+      result[key] = depth < 6 && value && typeof value === "object" && !Array.isArray(value) && prior && typeof prior === "object" && !Array.isArray(prior) ? merge2(prior, value, depth + 1) : value;
+    }
+    return result;
+  };
+  return userContext(merge2(current, userContext(next, redact2), 0), redact2);
+}
+function toSpanAttributes(context) {
+  return Object.fromEntries(
+    Object.entries(context).filter(([, item]) => item !== null && item !== void 0).map(([key, item]) => [
+      key,
+      typeof item === "object" ? JSON.stringify(item) : item
+    ])
+  );
+}
+var CODE_PATTERN = /^[a-z][a-z0-9_]*(\.[a-z0-9_]+){0,3}$/;
+var CODE_MAX_LENGTH = 80;
+var WHY_MAX = 1e3;
+var FIX_MAX = 1e3;
+var LINK_MAX = 500;
+var CAUSE_DEPTH = 5;
+function isValidErrorCode(code) {
+  return typeof code === "string" && code.length <= CODE_MAX_LENGTH && CODE_PATTERN.test(code);
+}
+var warned = /* @__PURE__ */ new Set();
+function warnInvalidCode(code) {
+  const key = String(code).slice(0, 120);
+  if (warned.has(key) || warned.size >= 50) return;
+  warned.add(key);
+  try {
+    console.warn(
+      `[autter-runtime] error code ${JSON.stringify(key)} does not match ${CODE_PATTERN} (max ${CODE_MAX_LENGTH} chars); it is dropped and the error groups by message`
+    );
+  } catch (e9) {
+  }
+}
+var RuntimeError = class extends Error {
+  
+  
+  
+  
+  
+  
+  constructor(options) {
+    const opts = typeof options === "string" ? { message: options } : options;
+    super(
+      opts.message,
+      opts.cause !== void 0 ? { cause: opts.cause } : void 0
+    );
+    this.name = "RuntimeError";
+    if (opts.code !== void 0) {
+      if (isValidErrorCode(opts.code)) this.code = opts.code;
+      else warnInvalidCode(opts.code);
+    }
+    if (typeof opts.why === "string") this.why = opts.why.slice(0, WHY_MAX);
+    if (typeof opts.fix === "string") this.fix = opts.fix.slice(0, FIX_MAX);
+    if (typeof opts.link === "string") this.link = opts.link.slice(0, LINK_MAX);
+    if (typeof opts.status === "number" && Number.isFinite(opts.status))
+      this.status = Math.trunc(opts.status);
+    if (typeof opts.expected === "boolean") this.expected = opts.expected;
+    if (opts.internal !== void 0)
+      Object.defineProperty(this, "internal", {
+        value: opts.internal,
+        enumerable: false,
+        writable: false,
+        configurable: true
+      });
+  }
+  /** Client-safe JSON (what `toClientError` returns, minus the wrapper). */
+  toJSON() {
+    return toClientError(this).error;
+  }
+};
+function defineRuntimeErrors(namespace, catalog) {
+  const out = {};
+  for (const [key, entry] of Object.entries(catalog)) {
+    const code = `${namespace}.${key}`;
+    const valid = isValidErrorCode(code);
+    if (!valid) warnInvalidCode(code);
+    const build = (definition, extras) => {
+      const error = new RuntimeError({
+        ...definition,
+        ..._optionalChain([extras, 'optionalAccess', _6 => _6.message]) !== void 0 ? { message: extras.message } : {},
+        ...valid ? { code } : {},
+        ..._optionalChain([extras, 'optionalAccess', _7 => _7.cause]) !== void 0 ? { cause: extras.cause } : {},
+        ..._optionalChain([extras, 'optionalAccess', _8 => _8.internal]) !== void 0 ? { internal: extras.internal } : {}
+      });
+      const captureStackTrace = Error.captureStackTrace;
+      _optionalChain([captureStackTrace, 'optionalCall', _9 => _9(error, factory)]);
+      return error;
+    };
+    const factory = typeof entry === "function" ? (args, extras) => build(entry(args), extras) : (extras) => build(entry, extras);
+    Object.defineProperty(factory, "code", { value: code, enumerable: true });
+    out[key] = factory;
+  }
+  return out;
+}
+function isRuntimeErrorLike(err) {
+  if (err instanceof RuntimeError) return true;
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return typeof e.code === "string" || typeof e.why === "string" || typeof e.fix === "string" || typeof e.link === "string" || typeof e.status === "number" || typeof e.statusCode === "number" || typeof e.expected === "boolean";
+}
+function field(err, key) {
+  if (!err || typeof err !== "object") return void 0;
+  try {
+    return err[key];
+  } catch (e10) {
+    return void 0;
+  }
+}
+function errorCodeOf(err) {
+  const code = field(err, "code");
+  return isValidErrorCode(code) ? code : void 0;
+}
+function errorStatusOf(err) {
+  for (const key of ["status", "statusCode"]) {
+    const status = field(err, key);
+    if (typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599)
+      return status;
+  }
+  return void 0;
+}
+function isExpectedError(err) {
+  return field(err, "expected") === true;
+}
+function errorAttributes(err, options = {}) {
+  const out = {};
+  if (!err || typeof err !== "object") return out;
+  const code = errorCodeOf(err);
+  if (code) out["autter.error.code"] = code;
+  const why = field(err, "why");
+  if (typeof why === "string" && why) out["autter.error.why"] = why.slice(0, WHY_MAX);
+  const fix = field(err, "fix");
+  if (typeof fix === "string" && fix) out["autter.error.fix"] = fix.slice(0, FIX_MAX);
+  const link = field(err, "link");
+  if (typeof link === "string" && link) out["autter.error.link"] = link.slice(0, LINK_MAX);
+  const status = errorStatusOf(err);
+  if (status !== void 0 && isRuntimeErrorLike(err)) out["autter.error.status"] = status;
+  const expected = field(err, "expected");
+  if (typeof expected === "boolean") out["autter.error.expected"] = expected;
+  if (options.causes !== false) {
+    let cause = field(err, "cause");
+    const seen = /* @__PURE__ */ new Set([err]);
+    for (let n = 1; n <= CAUSE_DEPTH && cause !== void 0 && cause !== null; n++) {
+      if (seen.has(cause)) break;
+      seen.add(cause);
+      const isError = typeof cause === "object";
+      const type = isError ? String(_nullishCoalesce(_nullishCoalesce(field(cause, "name"), () => ( _optionalChain([cause, 'access', _10 => _10.constructor, 'optionalAccess', _11 => _11.name]))), () => ( "Error"))) : typeof cause;
+      const message = isError ? field(cause, "message") : cause;
+      out[`exception.cause.${n}.type`] = type.slice(0, 200);
+      out[`exception.cause.${n}.message`] = String(_nullishCoalesce(message, () => ( ""))).slice(0, 1e3);
+      const causeCode = field(cause, "code");
+      if (typeof causeCode === "string" && causeCode)
+        out[`exception.cause.${n}.code`] = causeCode.slice(0, CODE_MAX_LENGTH);
+      cause = isError ? field(cause, "cause") : void 0;
+    }
+  }
+  return out;
+}
+function errorInternal(err) {
+  const internal = field(err, "internal");
+  return internal && typeof internal === "object" && !Array.isArray(internal) ? internal : void 0;
+}
+var GENERIC_MESSAGE = "Internal Server Error";
+function toClientError(err, requestId) {
+  const code = errorCodeOf(err);
+  const status = errorStatusOf(err);
+  const declared = err instanceof RuntimeError || code !== void 0 || status !== void 0 && status < 500 && isRuntimeErrorLike(err);
+  const rawMessage = field(err, "message");
+  const message = declared && typeof rawMessage === "string" && rawMessage ? rawMessage.slice(0, 1e3) : GENERIC_MESSAGE;
+  const body = { message };
+  if (code) body.code = code;
+  if (declared) {
+    const why = field(err, "why");
+    if (typeof why === "string" && why) body.why = why.slice(0, WHY_MAX);
+    const fix = field(err, "fix");
+    if (typeof fix === "string" && fix) body.fix = fix.slice(0, FIX_MAX);
+    const link = field(err, "link");
+    if (typeof link === "string" && link) body.link = link.slice(0, LINK_MAX);
+  }
+  if (typeof requestId === "string" && requestId) body.requestId = requestId;
+  return { error: body };
+}
+function responseStatusOf(err) {
+  const status = errorStatusOf(err);
+  return status !== void 0 && status >= 400 ? status : 500;
+}
+var INLINE_LOG_LIMIT = 50;
+var INLINE_MESSAGE_MAX = 300;
+var INLINE_CHARACTER_BUDGET = 6e3;
+var AI_MODEL_LIMIT = 10;
+function createInlineLogState(startedAt) {
+  return {
+    startedAt,
+    logs: [],
+    logsTruncated: false,
+    logCharacters: 0,
+    level: "info"
+  };
+}
+function appendInlineLog(state, level, message, attrs, redact2, now = Date.now()) {
+  state.level = maxLevel(state.level, level);
+  if (state.logs.length >= INLINE_LOG_LIMIT) {
+    state.logsTruncated = true;
+    return;
+  }
+  const text = String(_nullishCoalesce(boundContext({ message }, redact2).message, () => ( ""))).slice(
+    0,
+    INLINE_MESSAGE_MAX
+  );
+  let small;
+  if (attrs && Object.keys(attrs).length) {
+    small = boundContext(attrs, redact2);
+    const encoded = JSON.stringify(small);
+    if (encoded.length > 1e3) small = { "autter.context.truncated": true };
+  }
+  const size = text.length + (small ? JSON.stringify(small).length : 0);
+  if (state.logCharacters + size > INLINE_CHARACTER_BUDGET) {
+    state.logsTruncated = true;
+    return;
+  }
+  state.logCharacters += size;
+  state.logs.push({
+    t: Math.max(0, now - state.startedAt),
+    level,
+    message: text,
+    ...small ? { attrs: small } : {}
+  });
+}
+function addAiUsage(rollup, usage) {
+  const next = _nullishCoalesce(rollup, () => ( {
+    calls: 0,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cost_usd: 0,
+    models: []
+  }));
+  const count = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
+  next.calls += 1;
+  next.input_tokens += count(usage.inputTokens);
+  next.output_tokens += count(usage.outputTokens);
+  next.cache_read_tokens += count(usage.cacheReadTokens);
+  if (typeof usage.costUsd === "number" && Number.isFinite(usage.costUsd) && usage.costUsd > 0)
+    next.cost_usd = Math.round((next.cost_usd + usage.costUsd) * 1e8) / 1e8;
+  if (usage.model && !next.models.includes(usage.model) && next.models.length < AI_MODEL_LIMIT)
+    next.models.push(String(usage.model).slice(0, 100));
+  return next;
+}
+var TRACE_ID = /^[a-f0-9]{32}$/;
+var SPAN_ID = /^[a-f0-9]{16}$/;
+function createRuntimeEvent(input) {
+  const valid = input.traceId !== void 0 && TRACE_ID.test(input.traceId) && !/^0+$/.test(input.traceId);
+  return {
+    time: _nullishCoalesce(input.time, () => ( Date.now())),
+    level: input.level,
+    message: input.message,
+    attributes: input.attributes,
+    ...valid ? {
+      traceId: input.traceId,
+      ...input.spanId && SPAN_ID.test(input.spanId) ? { spanId: input.spanId } : { spanId: _nullishCoalesce(input.spanId, () => ( "")) }
+    } : {}
+  };
+}
+function isSummary(event) {
+  return event.attributes["autter.event.type"] === "operation";
+}
+var SEVERITY = { debug: 5, info: 9, warning: 13, error: 17 };
+function otlpValue(input) {
+  if (typeof input === "number") return { doubleValue: input };
+  if (typeof input === "boolean") return { boolValue: input };
+  if (Array.isArray(input))
+    return { arrayValue: { values: input.slice(0, 64).map(otlpValue) } };
+  if (input && typeof input === "object")
+    return {
+      kvlistValue: {
+        values: Object.entries(input).slice(0, 128).map(([key, item]) => ({ key, value: otlpValue(item) }))
+      }
+    };
+  return { stringValue: String(_nullishCoalesce(input, () => ( ""))).slice(0, 32e3) };
+}
+function toOtlpLogRecord(event) {
+  return {
+    timeUnixNano: String(BigInt(Math.trunc(event.time)) * 1000000n),
+    severityNumber: SEVERITY[event.level],
+    severityText: event.level.toUpperCase(),
+    body: otlpValue(event.message),
+    attributes: Object.entries(event.attributes).map(([key, item]) => ({
+      key,
+      value: otlpValue(item)
+    })),
+    ...event.traceId ? { traceId: event.traceId, spanId: _nullishCoalesce(event.spanId, () => ( "")) } : {}
+  };
+}
+function buildOtlpLogsRequest(resource, records) {
+  return {
+    resourceLogs: [
+      {
+        resource: {
+          attributes: Object.entries({
+            "service.name": resource.service,
+            "deployment.environment.name": resource.environment,
+            ...resource.release ? { "service.version": resource.release } : {},
+            ...resource.distro ? {
+              "telemetry.distro.name": resource.distro.name,
+              "telemetry.distro.version": resource.distro.version
+            } : {}
+          }).map(([key, item]) => ({ key, value: otlpValue(item) }))
+        },
+        scopeLogs: [
+          {
+            scope: { name: "autter-runtime" },
+            logRecords: records
+          }
+        ]
+      }
+    ]
+  };
+}
+var REQUEST_ID_PATTERN = /^[\w.-]{8,128}$/;
+var DEFAULT_REQUEST_ID_HEADER = "x-request-id";
+function randomId() {
+  const c = globalThis.crypto;
+  if (_optionalChain([c, 'optionalAccess', _12 => _12.randomUUID])) return c.randomUUID();
+  return "10000000-1000-4000-8000-100000000000".replace(
+    /[018]/g,
+    (d) => (Number(d) ^ Math.random() * 16 >> Number(d) / 4).toString(16)
+  );
+}
+function resolveRequestId(header) {
+  const value = Array.isArray(header) ? header[0] : header;
+  return typeof value === "string" && REQUEST_ID_PATTERN.test(value.trim()) ? value.trim() : randomId();
+}
+function normalizeRoutePath(path) {
+  const pathname = (_nullishCoalesce(path.split(/[?#]/)[0], () => ( ""))) || "/";
+  return pathname.split("/").map((segment) => {
+    if (!segment) return segment;
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+      segment
+    ))
+      return ":id";
+    if (/^\d+$/.test(segment)) return ":id";
+    if (/^[0-9a-f]{8,}$/i.test(segment)) return ":id";
+    return segment;
+  }).join("/").slice(0, 200);
+}
+function compileIgnore(patterns = []) {
+  const regexes = patterns.map((pattern) => {
+    let source = "";
+    for (let i = 0; i < pattern.length; i++) {
+      const char = pattern[i];
+      if (char === "*" && pattern[i + 1] === "*") {
+        source += ".*";
+        i++;
+      } else if (char === "*") source += "[^/]*";
+      else source += char.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    }
+    return new RegExp(`^${source}/?$`);
+  });
+  return (path) => {
+    const pathname = _nullishCoalesce(path.split(/[?#]/)[0], () => ( ""));
+    return regexes.some((re) => re.test(pathname));
+  };
+}
+function requestOutcome(input) {
+  if (input.explicit) return input.explicit;
+  if (input.error !== void 0 && isExpectedError(input.error)) return "degraded";
+  if (input.thrown || input.status !== void 0 && input.status >= 500)
+    return "failed";
+  if (input.aborted) return "cancelled";
+  return "succeeded";
+}
+var OPERATION_ID = /^[\w.-]{1,128}$/;
+var TRACEPARENT = /^00-([a-f0-9]{32})-([a-f0-9]{16})-([a-f0-9]{2})$/;
+function formatTraceparent(traceId, spanId, sampled) {
+  const value = `00-${traceId}-${spanId}-${sampled ? "01" : "00"}`;
+  return TRACEPARENT.test(value) && !/^0+$/.test(traceId) && !/^0+$/.test(spanId) ? value : void 0;
+}
+function parseTraceparent(value) {
+  if (typeof value !== "string") return null;
+  const match = TRACEPARENT.exec(value.trim());
+  if (!match || /^0+$/.test(match[1]) || /^0+$/.test(match[2])) return null;
+  return {
+    traceId: match[1],
+    spanId: match[2],
+    sampled: (Number.parseInt(match[3], 16) & 1) === 1
+  };
+}
+function createCarrier(input) {
+  return {
+    v: 1,
+    op: input.op,
+    ...input.req ? { req: input.req } : {},
+    ...input.traceparent ? { traceparent: input.traceparent } : {}
+  };
+}
+function parseCarrier(input) {
+  let value = input;
+  if (typeof value === "string") {
+    if (value.length > 1024) return null;
+    try {
+      value = JSON.parse(value);
+    } catch (e11) {
+      return null;
+    }
+  }
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (raw.v !== 1 || typeof raw.op !== "string" || !OPERATION_ID.test(raw.op))
+    return null;
+  return createCarrier({
+    op: raw.op,
+    ...typeof raw.req === "string" && REQUEST_ID_PATTERN.test(raw.req) ? { req: raw.req } : {},
+    ...parseTraceparent(raw.traceparent) ? { traceparent: String(raw.traceparent).trim() } : {}
+  });
+}
+var BOT = /bot\b|crawler|spider|crawling|slurp|headless|lighthouse|curl\/|wget\/|python-requests|httpclient|okhttp|go-http-client|axios\/|node-fetch|undici/i;
+function parseUserAgent(ua) {
+  const value = String(_nullishCoalesce(ua, () => ( ""))).slice(0, 512);
+  const os = /Windows/.test(value) ? "Windows" : /Android/.test(value) ? "Android" : /iPhone|iPad|iPod/.test(value) ? "iOS" : /Mac OS X/.test(value) ? "macOS" : /CrOS/.test(value) ? "ChromeOS" : /Linux/.test(value) ? "Linux" : "";
+  const edge = /Edg\/(\d+)/.exec(value);
+  const firefox = /Firefox\/(\d+)/.exec(value);
+  const chrome = /Chrome\/(\d+)/.exec(value);
+  const safari = /Version\/(\d+).+Safari/.exec(value);
+  const browser = edge ? `Edge ${edge[1]}` : firefox ? `Firefox ${firefox[1]}` : chrome ? `Chrome ${chrome[1]}` : safari ? `Safari ${safari[1]}` : "";
+  const bot = BOT.test(value);
+  const device = !value ? "unknown" : bot ? "bot" : /iPad|Tablet/.test(value) || /Android/.test(value) && !/Mobile/.test(value) ? "tablet" : /Mobi|iPhone|iPod|Android/.test(value) ? "mobile" : "desktop";
+  return { browser, os, device, bot };
+}
+
+// src/sinks.ts
+
+
+
+
+
+
+var _fs = require('fs');
+var _path = require('path');
+var sinkStats = { dropped: 0 };
+function otlpSink(options = {}) {
+  let context = null;
+  let queue = [];
+  let queueBytes = 0;
+  let inFlightBytes = 0;
+  let inFlight = 0;
+  let timer;
+  let flushing = null;
+  let stopping = false;
+  let failureStreak = 0;
+  const scheduleFlush = () => {
+    if (!timer && context && !stopping && queue.length) {
+      timer = setTimeout(
+        () => {
+          timer = void 0;
+          void flush().catch(() => {
+          });
+        },
+        Math.min(3e4, 2e3 * 2 ** Math.min(failureStreak, 4))
+      );
+      timer.unref();
+    }
+  };
+  const flush = async () => {
+    if (flushing) return flushing;
+    if (!context || !queue.length) return;
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    const active = context;
+    const endpoint = (_nullishCoalesce(options.endpoint, () => ( active.endpoint))).replace(/\/$/, "");
+    const apiKey = _nullishCoalesce(options.apiKey, () => ( active.apiKey));
+    const deadline = Date.now() + 1e4;
+    flushing = (async () => {
+      const count = queue.length;
+      for (let remaining = count; remaining > 0; ) {
+        const batch = [];
+        inFlightBytes = 0;
+        while (batch.length < Math.min(50, remaining) && queue.length) {
+          const next = queue[0];
+          if (batch.length && inFlightBytes + next.bytes > 512 * 1024) break;
+          batch.push(queue.shift());
+          inFlightBytes += next.bytes;
+          queueBytes -= next.bytes;
+        }
+        remaining -= batch.length;
+        inFlight = batch.length;
+        const body = JSON.stringify(
+          buildOtlpLogsRequest(
+            {
+              service: active.service,
+              environment: active.environment,
+              ...active.release ? { release: active.release } : {},
+              ...active.distro ? { distro: active.distro } : {}
+            },
+            batch.map((entry) => entry.record)
+          )
+        );
+        let failure;
+        for (let attempt = 0; attempt < 3; attempt++) {
+          try {
+            if (Date.now() >= deadline)
+              throw new Error("Runtime log flush exceeded 10 seconds");
+            const response = await fetch(`${endpoint}/v1/logs`, {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${apiKey}`
+              },
+              body,
+              signal: AbortSignal.timeout(
+                Math.max(1, Math.min(3e3, deadline - Date.now()))
+              )
+            });
+            _chunkGI47WGRRcjs.observeIngesterResponse.call(void 0, { status: response.status, headers: response.headers, route: "/v1/logs" });
+            if (!response.ok)
+              throw new Error(`Runtime log export failed (${response.status})`);
+            failure = void 0;
+            break;
+          } catch (error) {
+            failure = error;
+          }
+        }
+        inFlight = 0;
+        if (failure) {
+          failureStreak++;
+          queue = [...batch, ...queue];
+          queueBytes += inFlightBytes;
+          inFlightBytes = 0;
+          throw failure;
+        }
+        inFlightBytes = 0;
+        failureStreak = 0;
+      }
+    })().finally(() => {
+      flushing = null;
+      scheduleFlush();
+    });
+    return flushing;
+  };
+  return {
+    name: "otlp",
+    start(next) {
+      context = next;
+      stopping = false;
+      failureStreak = 0;
+    },
+    write(event) {
+      if (!context) return;
+      if (stopping) {
+        sinkStats.dropped++;
+        return;
+      }
+      const record = toOtlpLogRecord(event);
+      const bytes = Buffer.byteLength(JSON.stringify(record));
+      if (bytes > 256 * 1024 || queue.length + inFlight >= 1e3 || queueBytes + inFlightBytes + bytes > 4 * 1024 * 1024) {
+        sinkStats.dropped++;
+        console.warn(
+          "[autter-runtime] log buffer or record limit reached; record dropped"
+        );
+        return;
+      }
+      queue.push({ record, bytes });
+      queueBytes += bytes;
+      _chunkGI47WGRRcjs.noteCompatFeature.call(void 0, "operation_logging");
+      scheduleFlush();
+    },
+    flush,
+    async shutdown() {
+      stopping = true;
+      try {
+        await flush();
+      } finally {
+        if (queue.length) {
+          sinkStats.dropped += queue.length;
+          console.warn(
+            `[autter-runtime] ${queue.length} log records could not be delivered before shutdown`
+          );
+        }
+        queue = [];
+        queueBytes = 0;
+        context = null;
+        if (timer) clearTimeout(timer);
+        timer = void 0;
+      }
+    },
+    buffered: () => queue.length + inFlight
+  };
+}
+var ANSI = {
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  bold: "\x1B[1m",
+  reset: "\x1B[0m"
+};
+function shortValue(value) {
+  if (typeof value === "string") return /\s/.test(value) ? JSON.stringify(value) : value;
+  if (value && typeof value === "object") {
+    const text = JSON.stringify(value);
+    return text.length > 120 ? `${text.slice(0, 117)}...` : text;
+  }
+  return String(value);
+}
+function flatPairs(attributes) {
+  const pairs = [];
+  const visit = (prefix, value, depth) => {
+    if (pairs.length >= 24) return;
+    if (value && typeof value === "object" && !Array.isArray(value) && depth < 3) {
+      for (const [key, item] of Object.entries(value))
+        visit(prefix ? `${prefix}.${key}` : key, item, depth + 1);
+      return;
+    }
+    pairs.push(`${prefix}=${shortValue(value)}`);
+  };
+  for (const [key, value] of Object.entries(attributes)) {
+    if (/^(?:autter\.|exception\.|http\.(?:request\.method|route|response\.status_code)$)/.test(key))
+      continue;
+    visit(key, value, 0);
+  }
+  return pairs.join(" ");
+}
+function formatPretty(event, color = false) {
+  const paint = (code2, text) => color ? `${ANSI[code2]}${text}${ANSI.reset}` : text;
+  const a = event.attributes;
+  const time = new Date(event.time).toISOString().slice(11, 23);
+  const levelColor = event.level === "error" ? "red" : event.level === "warning" ? "yellow" : "dim";
+  const level = paint(levelColor, event.level.toUpperCase().padEnd(7));
+  if (!isSummary(event)) {
+    const context2 = flatPairs(a);
+    const op = typeof a["autter.operation.name"] === "string" ? paint("dim", ` [${a["autter.operation.name"]}]`) : "";
+    return `${paint("dim", time)} ${level} ${event.message}${context2 ? ` ${paint("dim", context2)}` : ""}${op}`;
+  }
+  const outcome = String(_nullishCoalesce(a["autter.operation.outcome"], () => ( "")));
+  const outcomeColor = outcome === "failed" ? "red" : outcome === "succeeded" ? "green" : "yellow";
+  const status = a["http.response.status_code"];
+  const head = [
+    paint("dim", time),
+    level,
+    paint("bold", String(_nullishCoalesce(a["autter.operation.name"], () => ( event.message)))),
+    paint(outcomeColor, outcome),
+    ...status !== void 0 ? [String(status)] : [],
+    `${Math.round(Number(_nullishCoalesce(a["autter.operation.duration_ms"], () => ( 0))))}ms`,
+    ...a["autter.request.id"] ? [paint("dim", `req=${a["autter.request.id"]}`)] : []
+  ].join(" ");
+  const lines = [head];
+  const row = (label, text) => lines.push(`  ${paint("cyan", label.padEnd(8))} ${text}`);
+  if (outcome !== "succeeded" && event.message && !event.message.endsWith(`: ${outcome}`))
+    row("message", event.message);
+  const context = flatPairs(a);
+  if (context) row("context", context);
+  const steps = a["autter.operation.steps"];
+  if (Array.isArray(steps) && steps.length)
+    row(
+      "steps",
+      steps.map((step) => {
+        const s = step;
+        const mark = s.status === "failed" ? paint("red", "\u2717") : paint("green", "\u2713");
+        return `${s.name} ${mark} ${s.durationMs}ms`;
+      }).join(" \xB7 ")
+    );
+  const code = a["autter.error.code"];
+  if (code || a["exception.type"])
+    row(
+      "error",
+      [
+        code ? paint("red", String(code)) : String(a["exception.type"]),
+        a["autter.error.expected"] === true ? paint("dim", "(expected)") : "",
+        a["autter.error.why"] ? `why: ${a["autter.error.why"]}` : "",
+        a["autter.error.fix"] ? `fix: ${a["autter.error.fix"]}` : ""
+      ].filter(Boolean).join(" ")
+    );
+  const ai = a["autter.operation.ai"];
+  if (ai && typeof ai === "object")
+    row(
+      "ai",
+      `${ai.calls} call(s) \xB7 ${ai.input_tokens} in / ${ai.output_tokens} out \xB7 $${ai.cost_usd} \xB7 ${(_nullishCoalesce(ai.models, () => ( []))).join(", ")}`
+    );
+  const logs = a["autter.operation.logs"];
+  if (Array.isArray(logs))
+    for (const entry of logs) {
+      const log = entry;
+      const extra = log.attrs ? ` ${paint("dim", flatPairs(log.attrs))}` : "";
+      row("log", `+${log.t}ms ${log.level} ${log.message}${extra}`);
+    }
+  if (a["autter.operation.logs_truncated"] === true) row("log", paint("dim", "\u2026 more messages truncated"));
+  return lines.join("\n");
+}
+function consoleSink(options = {}) {
+  const format = _nullishCoalesce(options.format, () => ( (process.env.NODE_ENV === "production" ? "json" : "pretty")));
+  const color = _nullishCoalesce(options.color, () => ( (_optionalChain([process, 'access', _13 => _13.stdout, 'optionalAccess', _14 => _14.isTTY]) === true && !process.env.NO_COLOR)));
+  const write = _nullishCoalesce(options.write, () => ( ((line) => console.log(line))));
+  return {
+    name: "console",
+    write(event) {
+      write(
+        format === "json" ? JSON.stringify({
+          ...event.attributes,
+          level: event.level,
+          message: event.message
+        }) : formatPretty(event, color)
+      );
+    }
+  };
+}
+var FILE_NAME = /^(\d{4}-\d{2}-\d{2})(?:\.(\d+))?\.jsonl$/;
+function fileSink(options = {}) {
+  const dir = _path.resolve.call(void 0, _nullishCoalesce(options.dir, () => ( ".autter/runtime")));
+  const maxFiles = Math.max(1, _nullishCoalesce(options.maxFiles, () => ( 7)));
+  const maxBytes = Math.max(1024, _nullishCoalesce(options.maxBytes, () => ( 10 * 1024 * 1024)));
+  let context = null;
+  let disabled = false;
+  let day = "";
+  let index = 0;
+  let currentBytes = 0;
+  const files = () => _fs.readdirSync.call(void 0, dir).map((name) => ({ name, match: FILE_NAME.exec(name) })).filter((file) => file.match).map((file) => ({
+    name: file.name,
+    day: file.match[1],
+    index: Number(_nullishCoalesce(file.match[2], () => ( 0)))
+  })).sort((a, b) => a.day === b.day ? a.index - b.index : a.day < b.day ? -1 : 1);
+  const fileName = (d, i) => i === 0 ? `${d}.jsonl` : `${d}.${i}.jsonl`;
+  const prune = () => {
+    const current = fileName(day, index);
+    const existing = files().filter((file) => file.name !== current);
+    const excess = existing.length + 1 - maxFiles;
+    for (const file of existing.slice(0, Math.max(0, excess)))
+      _fs.unlinkSync.call(void 0, _path.join.call(void 0, dir, file.name));
+  };
+  const open = (nextDay) => {
+    _fs.mkdirSync.call(void 0, dir, { recursive: true });
+    day = nextDay;
+    const sameDay = files().filter((file) => file.day === day);
+    index = sameDay.length ? sameDay[sameDay.length - 1].index : 0;
+    try {
+      currentBytes = _fs.statSync.call(void 0, _path.join.call(void 0, dir, fileName(day, index))).size;
+    } catch (e12) {
+      currentBytes = 0;
+    }
+    prune();
+  };
+  const disable = (error) => {
+    disabled = true;
+    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _15 => _15.code]), () => ( "error"));
+    console.warn(
+      `[autter-runtime] local runtime files disabled (${code} writing ${dir}); set logging.file: false to silence`
+    );
+  };
+  return {
+    name: "file",
+    start(next) {
+      context = next;
+    },
+    write(event) {
+      if (disabled) return;
+      try {
+        const line = `${JSON.stringify({
+          time: new Date(event.time).toISOString(),
+          level: event.level,
+          message: event.message,
+          ...context ? {
+            service: context.service,
+            environment: context.environment,
+            ...context.release ? { release: context.release } : {}
+          } : {},
+          ...event.traceId ? { traceId: event.traceId, spanId: event.spanId } : {},
+          ...event.attributes
+        })}
+`;
+        const bytes = Buffer.byteLength(line);
+        const today = new Date(event.time).toISOString().slice(0, 10);
+        if (today !== day) open(today);
+        if (currentBytes > 0 && currentBytes + bytes > maxBytes) {
+          index++;
+          currentBytes = 0;
+          prune();
+        }
+        _fs.appendFileSync.call(void 0, _path.join.call(void 0, dir, fileName(day, index)), line);
+        currentBytes += bytes;
+      } catch (error) {
+        disable(error);
+      }
+    }
+  };
+}
+function memorySink() {
+  const events = [];
+  const exceptions = [];
+  return {
+    name: "memory",
+    events,
+    exceptions,
+    write(event) {
+      events.push(event);
+    },
+    exception(record) {
+      exceptions.push(record);
+    },
+    clear() {
+      events.length = 0;
+      exceptions.length = 0;
+    }
+  };
+}
+
+// src/logger.ts
+var _async_hooks = require('async_hooks');
+var _crypto = require('crypto');
+
+
+var _api = require('@opentelemetry/api');
+var local = new (0, _async_hooks.AsyncLocalStorage)();
+var config = null;
+var sinks = [];
+var extraSinks = /* @__PURE__ */ new Set();
+var fallbackConsole = null;
+function redact(attributes) {
+  return _nullishCoalesce(_optionalChain([config, 'optionalAccess', _16 => _16.redact, 'call', _17 => _17(attributes)]), () => ( redactAttributes(attributes)));
+}
+var safe = (attributes = {}) => boundContext(attributes, redact);
+var merge = (current, next) => mergeContext(current, next, redact);
+function activeSinks() {
+  if (config) return extraSinks.size ? [...sinks, ...extraSinks] : sinks;
+  if (extraSinks.size) return [...extraSinks];
+  fallbackConsole ??= consoleSink();
+  return [fallbackConsole];
+}
+function defaultSinks(next) {
+  const options = _nullishCoalesce(next.options, () => ( {}));
+  if (options.sinks) return [...options.sinks];
+  const file = options.file === void 0 ? process.env.NODE_ENV === "development" : options.file !== false;
+  return [
+    ...next.apiKey ? [otlpSink()] : [],
+    ...options.console !== false ? [consoleSink()] : [],
+    ...file ? [fileSink(typeof options.file === "object" ? options.file : {})] : []
+  ];
+}
+function currentOperation() {
+  const state = local.getStore();
+  return state && !state.sealed ? state : void 0;
+}
+function operationAttributes(state) {
+  return state ? {
+    "autter.operation.id": state.id,
+    "autter.operation.name": state.name,
+    ...state.parentId ? { "autter.operation.parent_id": state.parentId } : {},
+    ...state.requestId ? { "autter.request.id": state.requestId } : {},
+    ...state.parentTraceId ? { "autter.parent_trace_id": state.parentTraceId } : {},
+    ...state.attributes
+  } : {};
+}
+function traceAttributes(state) {
+  return toSpanAttributes(operationAttributes(state));
+}
+function emit(level, message, attributes, extra = {}, options = {}) {
+  const state = options.state !== void 0 ? _nullishCoalesce(options.state, () => ( void 0)) : local.getStore();
+  if (_optionalChain([state, 'optionalAccess', _18 => _18.sealed])) return;
+  const summary = extra["autter.event.type"] === "operation";
+  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[_nullishCoalesce(_optionalChain([config, 'optionalAccess', _19 => _19.options, 'optionalAccess', _20 => _20.minLevel]), () => ( "debug"))])
+    return;
+  if (!summary && state && _optionalChain([config, 'optionalAccess', _21 => _21.options, 'optionalAccess', _22 => _22.inline]) !== false) {
+    const { "exception.stacktrace": _stack, ...inlineAttrs } = userContext(
+      attributes,
+      redact
+    );
+    appendInlineLog(state.inline, level, message, inlineAttrs, redact);
+    if (level === "debug" || level === "info") return;
+  }
+  const span = _nullishCoalesce(options.span, () => ( _optionalChain([_api.trace, 'access', _23 => _23.getActiveSpan, 'call', _24 => _24(), 'optionalAccess', _25 => _25.spanContext, 'call', _26 => _26()])));
+  const user = merge(_nullishCoalesce(_optionalChain([state, 'optionalAccess', _27 => _27.attributes]), () => ( {})), attributes);
+  const exceptions = Object.fromEntries(
+    Object.entries(user).filter(([key]) => key.startsWith("exception."))
+  );
+  const raw = {
+    "autter.event.id": _crypto.randomUUID.call(void 0, ),
+    ...extra,
+    ...exceptions,
+    ...operationAttributes(state),
+    ...user
+  };
+  const enrichers = _optionalChain([config, 'optionalAccess', _28 => _28.options, 'optionalAccess', _29 => _29.enrich]);
+  if (summary && state && _optionalChain([enrichers, 'optionalAccess', _30 => _30.length])) {
+    const event2 = { level, message, attributes: raw };
+    for (const enrich of enrichers) {
+      try {
+        enrich(event2, {
+          req: state.req,
+          res: state.res,
+          operation: { id: state.id, name: state.name, kind: state.kind }
+        });
+      } catch (e13) {
+      }
+    }
+  }
+  const event = createRuntimeEvent({
+    level,
+    message: String(_nullishCoalesce(safe({ message }).message, () => ( ""))).slice(0, 4e3),
+    attributes: safe(raw),
+    ...span ? { traceId: span.traceId, spanId: span.spanId } : {}
+  });
+  for (const sink of activeSinks()) {
+    try {
+      sink.write(event);
+    } catch (e14) {
+    }
+  }
+}
+function configureRuntimeLogger(next) {
+  config = next;
+  sinks = defaultSinks(next);
+  for (const sink of sinks) {
+    try {
+      _optionalChain([sink, 'access', _31 => _31.start, 'optionalCall', _32 => _32({
+        endpoint: next.endpoint,
+        apiKey: next.apiKey,
+        service: next.service,
+        environment: next.environment,
+        ...next.release ? { release: next.release } : {},
+        ...next.distro ? { distro: next.distro } : {}
+      })]);
+    } catch (e15) {
+    }
+  }
+}
+function addRuntimeSink(sink) {
+  extraSinks.add(sink);
+  return () => extraSinks.delete(sink);
+}
+function notifyException(error, attributes = {}) {
+  if (!extraSinks.size && !sinks.some((sink) => sink.exception)) return;
+  const state = local.getStore();
+  const record = {
+    time: Date.now(),
+    error,
+    message: error instanceof Error ? error.message : String(error),
+    type: error instanceof Error ? error.name : "Error",
+    attributes: { ...attributes, ...errorAttributes(error) },
+    ...state ? { operationId: state.id } : {},
+    ..._optionalChain([state, 'optionalAccess', _33 => _33.requestId]) ? { requestId: state.requestId } : {}
+  };
+  for (const sink of [...sinks, ...extraSinks]) {
+    try {
+      _optionalChain([sink, 'access', _34 => _34.exception, 'optionalCall', _35 => _35(record)]);
+    } catch (e16) {
+    }
+  }
+}
+function runtimeLogStats() {
+  return {
+    buffered: sinks.reduce((sum, sink) => sum + (_nullishCoalesce(_optionalChain([sink, 'access', _36 => _36.buffered, 'optionalCall', _37 => _37()]), () => ( 0))), 0),
+    dropped: sinkStats.dropped
+  };
+}
+async function flushRuntimeLogs() {
+  if (!config) return;
+  const results = await Promise.allSettled(
+    sinks.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _38 => _38.flush, 'optionalCall', _39 => _39()])))
+  );
+  const failed = results.find((result) => result.status === "rejected");
+  if (failed) throw failed.reason;
+}
+async function shutdownRuntimeLogger() {
+  const active = sinks;
+  const results = await Promise.allSettled(
+    active.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _40 => _40.shutdown, 'optionalCall', _41 => _41()])))
+  );
+  config = null;
+  sinks = [];
+  const failed = results.find((result) => result.status === "rejected");
+  if (failed) throw failed.reason;
+}
+function noteOperationError(error, thrown = false, state = currentOperation()) {
+  if (!state || state.sealed) return;
+  state.error = error;
+  if (thrown) state.errorThrown = true;
+}
+function recordOperationAiUsage(usage) {
+  const state = currentOperation();
+  if (state) state.ai = addAiUsage(state.ai, usage);
+}
+function createRuntimeLogger(attributes = {}) {
+  const attrs = userContext(attributes, redact);
+  return {
+    debug: (message, extra) => emit("debug", message, merge(attrs, extra)),
+    info: (message, extra) => emit("info", message, merge(attrs, extra)),
+    warn: (message, extra) => emit("warning", message, merge(attrs, extra)),
+    error: (error, extra) => emit(
+      "error",
+      error instanceof Error ? error.message : String(error),
+      {
+        ...attrs,
+        ...extra,
+        ...error instanceof Error ? {
+          "exception.type": error.name,
+          "exception.stacktrace": _nullishCoalesce(error.stack, () => ( ""))
+        } : {}
+      },
+      errorAttributes(error)
+    )
+  };
+}
+var runtimeLogger = createRuntimeLogger();
+function captureExceptionAsLog(error, attributes = {}) {
+  const isError = error instanceof Error;
+  const message = isError ? error.message : String(error);
+  const stack = isError && error.stack ? error.stack : _nullishCoalesce(_optionalChain([new Error(), 'access', _42 => _42.stack, 'optionalAccess', _43 => _43.split, 'call', _44 => _44("\n"), 'access', _45 => _45.filter, 'call', _46 => _46((line, i) => i === 0 || !/captureException/.test(line)), 'access', _47 => _47.join, 'call', _48 => _48("\n")]), () => ( ""));
+  noteOperationError(error);
+  emit(
+    "error",
+    message,
+    {
+      ...attributes,
+      "exception.type": isError ? error.name : "Error",
+      "exception.message": message,
+      "exception.stacktrace": stack
+    },
+    { "autter.capture.mode": "log", ...errorAttributes(error) }
+  );
+}
+function newState(name, kind, attributes, link) {
+  const startedAt = Date.now();
+  return {
+    id: _crypto.randomUUID.call(void 0, ),
+    name: String(safe({ name }).name).slice(0, 200),
+    kind,
+    ...link.parentId ? { parentId: link.parentId } : {},
+    ...link.requestId ? { requestId: link.requestId } : {},
+    ...link.parentTraceId ? { parentTraceId: link.parentTraceId } : {},
+    attributes: merge(_nullishCoalesce(link.base, () => ( {})), attributes),
+    startedAt,
+    outcome: "succeeded",
+    steps: [],
+    inline: createInlineLogState(startedAt)
+  };
+}
+function createRequestState(input) {
+  const parent = currentOperation();
+  const state = newState(input.name, "request", {}, {
+    requestId: input.requestId,
+    ...parent ? { parentId: parent.id } : {}
+  });
+  state.req = input.req;
+  state.res = input.res;
+  return state;
+}
+function setOutcome(state, status, message) {
+  if (state.sealed) return;
+  state.outcome = status;
+  state.explicitOutcome = true;
+  state.message = message;
+  if (status === "failed")
+    state.reportingStack = _nullishCoalesce(new Error("Operation outcome reported here").stack, () => ( ""));
+}
+function operationHandle(state) {
+  return {
+    id: state.id,
+    setContext: (attrs) => {
+      if (!state.sealed) {
+        state.attributes = merge(state.attributes, attrs);
+        _optionalChain([_api.trace, 'access', _49 => _49.getActiveSpan, 'call', _50 => _50(), 'optionalAccess', _51 => _51.setAttributes, 'call', _52 => _52(traceAttributes(state))]);
+      }
+    },
+    outcome: (status, message) => setOutcome(state, status, message),
+    step: async (stepName, stepFn) => {
+      const started = Date.now();
+      let status = "succeeded";
+      try {
+        return await stepFn();
+      } catch (error) {
+        status = "failed";
+        throw error;
+      } finally {
+        if (!state.sealed && state.steps.length < 64)
+          state.steps.push({
+            name: String(safe({ name: stepName }).name).slice(0, 200),
+            status,
+            durationMs: Date.now() - started
+          });
+      }
+    }
+  };
+}
+function summaryExtra(state, level, http = {}) {
+  const err = state.error;
+  return {
+    "autter.event.type": "operation",
+    "autter.operation.outcome": state.outcome,
+    "autter.operation.duration_ms": Date.now() - state.startedAt,
+    "autter.operation.steps": state.steps,
+    "autter.operation.kind": state.kind,
+    "autter.operation.level": maxLevel(state.inline.level, level),
+    ...state.ai ? { "autter.operation.ai": state.ai } : {},
+    ...http,
+    ...err !== void 0 ? errorAttributes(err) : {},
+    ...state.inline.logsTruncated ? { "autter.operation.logs_truncated": true } : {},
+    ...state.inline.logs.length ? { "autter.operation.logs": state.inline.logs } : {}
+  };
+}
+function emitSummary(state, options = {}) {
+  if (state.sealed) return;
+  const err = state.error;
+  const level = state.outcome === "failed" ? "error" : "info";
+  emit(
+    level,
+    _nullishCoalesce(state.message, () => ( `${state.name}: ${state.outcome}`)),
+    {
+      ...operationAttributes(state),
+      ...err instanceof Error ? {
+        "exception.type": err.name,
+        "exception.stacktrace": _nullishCoalesce(err.stack, () => ( ""))
+      } : {}
+    },
+    summaryExtra(state, level, options.http),
+    { state, ...options.span ? { span: options.span } : {} }
+  );
+  state.sealed = true;
+}
+function reportExplicitFailure(state) {
+  if (state.outcome === "failed" && state.explicitOutcome && !state.errorThrown)
+    _optionalChain([config, 'optionalAccess', _53 => _53.reportOutcome, 'call', _54 => _54(state.name, _nullishCoalesce(state.message, () => ( "Operation failed")), {
+      ...traceAttributes(state),
+      "autter.outcome.stack": _nullishCoalesce(state.reportingStack, () => ( ""))
+    })]);
+}
+function startOperation(name, fn, attributes, options, internal = {}) {
+  const parent = _nullishCoalesce(internal.forkParent, () => ( local.getStore()));
+  const carrier = options.from ? parseCarrier(options.from) : null;
+  const traceparent = _optionalChain([carrier, 'optionalAccess', _55 => _55.traceparent]) ? parseTraceparent(carrier.traceparent) : null;
+  const linked = internal.forkParent !== void 0 || parent && !parent.sealed;
+  const state = newState(
+    name,
+    "operation",
+    attributes,
+    carrier ? {
+      parentId: carrier.op,
+      ...carrier.req ? { requestId: carrier.req } : {},
+      ...traceparent ? { parentTraceId: traceparent.traceId } : {}
+    } : {
+      ...linked && parent ? { parentId: parent.id, base: parent.attributes } : {},
+      ..._optionalChain([parent, 'optionalAccess', _56 => _56.requestId]) ? { requestId: parent.requestId } : {}
+    }
+  );
+  const operation = operationHandle(state);
+  const run = () => local.run(state, async () => {
+    let thrown;
+    try {
+      return await fn(operation);
+    } catch (error) {
+      state.outcome = "failed";
+      thrown = error;
+      noteOperationError(error, true, state);
+      _optionalChain([config, 'optionalAccess', _57 => _57.captureThrown, 'optionalCall', _58 => _58(error)]);
+      throw error;
+    } finally {
+      _optionalChain([_api.trace, 'access', _59 => _59.getActiveSpan, 'call', _60 => _60(), 'optionalAccess', _61 => _61.setAttributes, 'call', _62 => _62({
+        ...traceAttributes(state),
+        "autter.operation.outcome": state.outcome,
+        "autter.operation.kind": state.kind
+      })]);
+      if (state.outcome === "failed" && !thrown)
+        _optionalChain([config, 'optionalAccess', _63 => _63.reportOutcome, 'call', _64 => _64(
+          state.name,
+          _nullishCoalesce(state.message, () => ( "Operation failed")),
+          {
+            ...traceAttributes(state),
+            "autter.outcome.stack": _nullishCoalesce(state.reportingStack, () => ( ""))
+          }
+        )]);
+      emitSummary(state);
+    }
+  });
+  const links = traceparent ? [
+    {
+      context: {
+        traceId: traceparent.traceId,
+        spanId: traceparent.spanId,
+        traceFlags: traceparent.sampled ? 1 : 0,
+        isRemote: true
+      }
+    }
+  ] : [];
+  const promise = _optionalChain([config, 'optionalAccess', _65 => _65.run]) ? config.run(state.name, run, traceAttributes(state), links) : run();
+  if (!options.waitUntil) return promise;
+  const waitUntil = options.waitUntil;
+  return promise.finally(() => {
+    try {
+      waitUntil(flushRuntimeLogs().catch(() => {
+      }));
+    } catch (e17) {
+    }
+  });
+}
+function withRuntimeOperation(name, fn, attributes = {}, options = {}) {
+  return startOperation(name, fn, attributes, options);
+}
+function runInBackground(name, fn) {
+  return runtimeContext.fork(name, fn).catch(() => void 0);
+}
+var runtimeContext = {
+  /** Merge attributes into the current summary's context. */
+  set(attributes) {
+    const state = currentOperation();
+    if (!state) return;
+    state.attributes = merge(state.attributes, attributes);
+    _optionalChain([_api.trace, 'access', _66 => _66.getActiveSpan, 'call', _67 => _67(), 'optionalAccess', _68 => _68.setAttributes, 'call', _69 => _69(traceAttributes(state))]);
+  },
+  /** Set the outcome explicitly (wins over status/thrown-error rules). */
+  outcome(status, message) {
+    const state = currentOperation();
+    if (state) setOutcome(state, status, message);
+  },
+  debug(message, attributes) {
+    runtimeLogger.debug(message, attributes);
+  },
+  info(message, attributes) {
+    runtimeLogger.info(message, attributes);
+  },
+  warn(message, attributes) {
+    runtimeLogger.warn(message, attributes);
+  },
+  /** Log an error and attach it (code/why/fix) to the current summary. */
+  error(error, attributes) {
+    noteOperationError(error);
+    runtimeLogger.error(error, attributes);
+  },
+  /** Current operation id. */
+  get id() {
+    return _optionalChain([local, 'access', _70 => _70.getStore, 'call', _71 => _71(), 'optionalAccess', _72 => _72.id]);
+  },
+  /** Current request id (inherited by child operations and forks). */
+  get requestId() {
+    return _optionalChain([local, 'access', _73 => _73.getStore, 'call', _74 => _74(), 'optionalAccess', _75 => _75.requestId]);
+  },
+  /**
+   * Run `fn` as a child operation whose parent link is captured NOW, so it
+   * still links after the parent has finished (background work).
+   */
+  fork(name, fn) {
+    const parent = local.getStore();
+    return startOperation(name, fn, {}, {}, parent ? { forkParent: parent } : {});
+  },
+  /** Serialisable link for queue payloads: `{ v: 1, op, req?, traceparent? }`. */
+  carrier() {
+    const state = local.getStore();
+    if (!state) return void 0;
+    const span = _optionalChain([_api.trace, 'access', _76 => _76.getActiveSpan, 'call', _77 => _77(), 'optionalAccess', _78 => _78.spanContext, 'call', _79 => _79()]);
+    const traceparent = span ? formatTraceparent(span.traceId, span.spanId, (span.traceFlags & 1) === 1) : void 0;
+    return createCarrier({
+      op: state.id,
+      ...state.requestId ? { req: state.requestId } : {},
+      ...traceparent ? { traceparent } : {}
+    });
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.redactAttributes = redactAttributes; exports.redactText = redactText; exports.makeRedactor = makeRedactor; exports.CODE_PATTERN = CODE_PATTERN; exports.RuntimeError = RuntimeError; exports.defineRuntimeErrors = defineRuntimeErrors; exports.isRuntimeErrorLike = isRuntimeErrorLike; exports.errorCodeOf = errorCodeOf; exports.errorAttributes = errorAttributes; exports.errorInternal = errorInternal; exports.toClientError = toClientError; exports.responseStatusOf = responseStatusOf; exports.isSummary = isSummary; exports.DEFAULT_REQUEST_ID_HEADER = DEFAULT_REQUEST_ID_HEADER; exports.resolveRequestId = resolveRequestId; exports.normalizeRoutePath = normalizeRoutePath; exports.compileIgnore = compileIgnore; exports.requestOutcome = requestOutcome; exports.parseUserAgent = parseUserAgent; exports.otlpSink = otlpSink; exports.consoleSink = consoleSink; exports.fileSink = fileSink; exports.memorySink = memorySink; exports.local = local; exports.currentOperation = currentOperation; exports.configureRuntimeLogger = configureRuntimeLogger; exports.addRuntimeSink = addRuntimeSink; exports.notifyException = notifyException; exports.runtimeLogStats = runtimeLogStats; exports.flushRuntimeLogs = flushRuntimeLogs; exports.shutdownRuntimeLogger = shutdownRuntimeLogger; exports.noteOperationError = noteOperationError; exports.recordOperationAiUsage = recordOperationAiUsage; exports.createRuntimeLogger = createRuntimeLogger; exports.runtimeLogger = runtimeLogger; exports.captureExceptionAsLog = captureExceptionAsLog; exports.createRequestState = createRequestState; exports.emitSummary = emitSummary; exports.reportExplicitFailure = reportExplicitFailure; exports.withRuntimeOperation = withRuntimeOperation; exports.runInBackground = runInBackground; exports.runtimeContext = runtimeContext;