@kyncode/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1434 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Loly: () => Loly,
+  SDK_VERSION: () => SDK_VERSION,
+  default: () => index_default,
+  onRequestError: () => onRequestError,
+  register: () => register
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sanitizer.ts
+var MAX_SANITIZE_DEPTH = 6;
+var MAX_SANITIZE_NODES = 500;
+var MAX_SANITIZED_STRING_LENGTH = 4096;
+var MAX_SANITIZED_COLLECTION_SIZE = 100;
+var MAX_SANITIZER_INPUT_LENGTH = MAX_SANITIZED_STRING_LENGTH * 4;
+var REDACTED_SECRET = "[REDACTED_SECRET]";
+var REDACTED_BEARER_TOKEN = "[REDACTED_BEARER_TOKEN]";
+var REDACTED_JWT = "[REDACTED_JWT]";
+var REDACTED_CARD = "[REDACTED_CARD]";
+var REDACTED_PRIVATE_KEY = "[REDACTED_PRIVATE_KEY]";
+var REDACTED_DATABASE_URL = "[REDACTED_DATABASE_URL]";
+var CIRCULAR_REFERENCE = "[CIRCULAR]";
+var DEPTH_LIMIT = "[TRUNCATED_DEPTH]";
+var NODE_LIMIT = "[TRUNCATED_NODES]";
+var COLLECTION_LIMIT_KEY = "__kyncode_truncated__";
+var SENSITIVE_KEY_NAMES = /* @__PURE__ */ new Set([
+  "accesskey",
+  "accesstoken",
+  "apikey",
+  "auth",
+  "authorization",
+  "bearer",
+  "card",
+  "clientsecret",
+  "connectionstring",
+  "cookie",
+  "creditcard",
+  "credential",
+  "credentials",
+  "cvv",
+  "databaseurl",
+  "dburl",
+  "code",
+  "csrftoken",
+  "idtoken",
+  "invitecode",
+  "jwt",
+  "nonce",
+  "otp",
+  "pan",
+  "pass",
+  "passwd",
+  "password",
+  "pin",
+  "privatekey",
+  "refreshtoken",
+  "resetcode",
+  "secret",
+  "session",
+  "setcookie",
+  "sig",
+  "signature",
+  "state",
+  "token",
+  "verificationcode",
+  "xapikey"
+]);
+var SENSITIVE_SEGMENTS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "credential",
+  "cvv",
+  "jwt",
+  "passwd",
+  "password",
+  "secret",
+  "session",
+  "token"
+]);
+var PRIVATE_KEY_PATTERN = /-----BEGIN [A-Z\d ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z\d ]*PRIVATE KEY-----/giu;
+var PARTIAL_PRIVATE_KEY_PATTERN = /-----BEGIN [A-Z\d ]*PRIVATE KEY-----[\s\S]*$/giu;
+var DATABASE_URL_PATTERN = /\b(?:mongodb(?:\+srv)?|mysql|postgres(?:ql)?|redis|rediss):\/\/[^\s'"<>]+/giu;
+var URL_CREDENTIAL_PATTERN = /(https?:\/\/)[^\s/@:]+:[^\s/@]+@/giu;
+var BEARER_TOKEN_PATTERN = /\bBearer\s+[A-Za-z0-9\-._~+/]{8,}=*/giu;
+var JWT_PATTERN = /(?<![A-Za-z0-9_-])[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_+/=-]{8,}(?![A-Za-z0-9_+/=-])/gu;
+var KYNCODE_KEY_PATTERN = /\bkyn_(?:live|test)_[a-f0-9]{16,}\b/giu;
+var PROVIDER_TOKEN_PATTERN = /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}|xox[baprs]-[A-Za-z0-9-]{10,}|(?:AKIA|ASIA)[A-Z0-9]{16}|sk-[A-Za-z0-9_-]{20,})\b/gu;
+var SECRET_ASSIGNMENT_HEADER_PATTERN = /(?<![A-Za-z0-9_-])(["'`]?)([A-Za-z0-9_-]{1,256})\1\s*[:=]\s*/gimu;
+var CARD_PATTERN = /(?<!\d)(?:\d[ -]?){12,18}\d(?!\d)/gu;
+function sanitizeClientData(input) {
+  return sanitizeValue(input, { nodes: 0, seen: /* @__PURE__ */ new WeakSet() }, 0);
+}
+function sanitizeStringRecord(input) {
+  const entries = Object.entries(input).slice(0, MAX_SANITIZED_COLLECTION_SIZE);
+  const sanitized = entries.map(([key, value], index) => [
+    sanitizeOutputKey(key, index),
+    isSensitiveKey(key) ? REDACTED_SECRET : sanitizeText(value)
+  ]);
+  if (Object.keys(input).length > entries.length) {
+    sanitized.push([COLLECTION_LIMIT_KEY, "Additional fields were omitted"]);
+  }
+  return Object.fromEntries(sanitized);
+}
+function sanitizeText(value) {
+  const boundedValue = value.slice(0, MAX_SANITIZER_INPUT_LENGTH);
+  const omittedInputCharacters = value.length - boundedValue.length;
+  const embeddedSecretsRedacted = boundedValue.replace(PRIVATE_KEY_PATTERN, REDACTED_PRIVATE_KEY).replace(PARTIAL_PRIVATE_KEY_PATTERN, REDACTED_PRIVATE_KEY).replace(DATABASE_URL_PATTERN, REDACTED_DATABASE_URL).replace(URL_CREDENTIAL_PATTERN, `$1${REDACTED_SECRET}@`).replace(BEARER_TOKEN_PATTERN, REDACTED_BEARER_TOKEN).replace(JWT_PATTERN, REDACTED_JWT).replace(KYNCODE_KEY_PATTERN, REDACTED_SECRET).replace(PROVIDER_TOKEN_PATTERN, REDACTED_SECRET);
+  const assignmentsRedacted = redactSecretAssignments(embeddedSecretsRedacted);
+  const redacted = assignmentsRedacted.replace(CARD_PATTERN, REDACTED_CARD);
+  return truncateString(redacted, omittedInputCharacters);
+}
+function redactSecretAssignments(value) {
+  SECRET_ASSIGNMENT_HEADER_PATTERN.lastIndex = 0;
+  let cursor = 0;
+  let output = "";
+  let match;
+  while ((match = SECRET_ASSIGNMENT_HEADER_PATTERN.exec(value)) !== null) {
+    const quote = match[1] ?? "";
+    const key = match[2];
+    if (key === void 0 || !isSensitiveKey(key)) continue;
+    const valueStart = SECRET_ASSIGNMENT_HEADER_PATTERN.lastIndex;
+    const valueEnd = findAssignmentValueEnd(value, valueStart, match.index, quote);
+    output += value.slice(cursor, match.index);
+    output += `${quote}${key}${quote}=${REDACTED_SECRET}`;
+    cursor = valueEnd;
+    SECRET_ASSIGNMENT_HEADER_PATTERN.lastIndex = Math.max(valueEnd, valueStart);
+  }
+  SECRET_ASSIGNMENT_HEADER_PATTERN.lastIndex = 0;
+  return `${output}${value.slice(cursor)}`;
+}
+function findAssignmentValueEnd(value, valueStart, headerStart, keyQuote) {
+  const valueQuote = value[valueStart];
+  if (isQuote(valueQuote)) return scanToClosingQuote(value, valueStart + 1, valueQuote, true);
+  const enclosingQuote = keyQuote === "" ? value[headerStart - 1] : void 0;
+  if (isQuote(enclosingQuote) && !isEscapedAt(value, headerStart - 1)) {
+    return scanToClosingQuote(value, valueStart, enclosingQuote, false);
+  }
+  let cursor = valueStart;
+  while (cursor < value.length && !isUnquotedAssignmentDelimiter(value[cursor])) cursor += 1;
+  return cursor;
+}
+function scanToClosingQuote(value, start, quote, includeClosingQuote) {
+  let escaped = false;
+  for (let cursor = start; cursor < value.length; cursor += 1) {
+    const character = value[cursor];
+    if (character === "\r" || character === "\n") return cursor;
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === quote) return includeClosingQuote ? cursor + 1 : cursor;
+  }
+  return value.length;
+}
+function isEscapedAt(value, index) {
+  let backslashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+function isQuote(value) {
+  return value === '"' || value === "'" || value === "`";
+}
+function isUnquotedAssignmentDelimiter(value) {
+  return value === void 0 || value === "\r" || value === "\n" || value === "," || value === ";" || value === "&";
+}
+function isSensitiveKey(key) {
+  const separated = key.replace(/([a-z\d])([A-Z])/gu, "$1_$2").toLowerCase();
+  const segments = separated.split(/[^a-z0-9]+/u).filter((segment) => segment !== "");
+  const canonical = segments.join("");
+  return SENSITIVE_KEY_NAMES.has(canonical) || segments.some((segment) => SENSITIVE_SEGMENTS.has(segment)) || segments.includes("api") && segments.includes("key") || segments.includes("private") && segments.includes("key") || segments.includes("database") && segments.includes("url") || segments.includes("connection") && segments.includes("string");
+}
+function sanitizeValue(value, state, depth) {
+  state.nodes += 1;
+  if (state.nodes > MAX_SANITIZE_NODES) return NODE_LIMIT;
+  if (depth > MAX_SANITIZE_DEPTH) return DEPTH_LIMIT;
+  if (value === null || value === void 0 || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "string") return sanitizeText(value);
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "function" || typeof value === "symbol") {
+    return `[${(typeof value).toUpperCase()}]`;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) return "[REDACTED_BUFFER]";
+  if (isDateLike(value)) return sanitizeDate(value);
+  if (state.seen.has(value)) return CIRCULAR_REFERENCE;
+  state.seen.add(value);
+  const sanitized = Array.isArray(value) ? sanitizeArray(value, state, depth) : sanitizeObject(value, state, depth);
+  state.seen.delete(value);
+  return sanitized;
+}
+function sanitizeArray(value, state, depth) {
+  const sanitized = value.slice(0, MAX_SANITIZED_COLLECTION_SIZE).map((item) => sanitizeValue(item, state, depth + 1));
+  return value.length > sanitized.length ? [...sanitized, `[TRUNCATED_${String(value.length - sanitized.length)}_ITEMS]`] : sanitized;
+}
+function sanitizeObject(value, state, depth) {
+  const entries = safeEntries(value);
+  if (entries === void 0) return "[UNREADABLE_OBJECT]";
+  const limitedEntries = entries.slice(0, MAX_SANITIZED_COLLECTION_SIZE);
+  const sanitized = limitedEntries.map(([key, childValue], index) => [
+    sanitizeOutputKey(key, index),
+    isSensitiveKey(key) ? REDACTED_SECRET : sanitizeValue(childValue, state, depth + 1)
+  ]);
+  if (entries.length > limitedEntries.length) {
+    sanitized.push([
+      COLLECTION_LIMIT_KEY,
+      `Omitted ${String(entries.length - limitedEntries.length)} fields`
+    ]);
+  }
+  return Object.fromEntries(sanitized);
+}
+function safeEntries(value) {
+  try {
+    return Object.entries(value);
+  } catch {
+    return void 0;
+  }
+}
+function isDateLike(value) {
+  try {
+    return Object.prototype.toString.call(value) === "[object Date]";
+  } catch {
+    return false;
+  }
+}
+function sanitizeDate(value) {
+  try {
+    const milliseconds = Date.prototype.getTime.call(value);
+    return Number.isNaN(milliseconds) ? "[INVALID_DATE]" : new Date(milliseconds).toISOString();
+  } catch {
+    return "[INVALID_DATE]";
+  }
+}
+function truncateString(value, omittedInputCharacters = 0) {
+  const omittedOutputCharacters = Math.max(0, value.length - MAX_SANITIZED_STRING_LENGTH);
+  const totalOmittedCharacters = omittedInputCharacters + omittedOutputCharacters;
+  if (totalOmittedCharacters === 0) return value;
+  return `${value.slice(0, MAX_SANITIZED_STRING_LENGTH)}[TRUNCATED_${String(totalOmittedCharacters)}_CHARS]`;
+}
+function sanitizeOutputKey(key, index) {
+  if (key === "__proto__" || key === "constructor" || key === "prototype") {
+    return `[UNSAFE_KEY_${String(index)}]`;
+  }
+  return sanitizeText(key) === key ? key : `[REDACTED_KEY_${String(index)}]`;
+}
+
+// src/request-capture.ts
+var BODY_CAPTURE_TIMEOUT_MS = 50;
+var MAX_CAPTURED_BODY_BYTES = 32768;
+var REDACTED_QUERY_VALUE = "[REDACTED_QUERY_VALUE]";
+var ALLOWED_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "content-type",
+  "sentry-trace",
+  "traceparent",
+  "user-agent",
+  "x-correlation-id",
+  "x-request-id",
+  "x-vercel-id"
+]);
+var VALID_METHODS = /* @__PURE__ */ new Set([
+  "DELETE",
+  "GET",
+  "HEAD",
+  "OPTIONS",
+  "PATCH",
+  "POST",
+  "PUT"
+]);
+function captureStructuredRequest(input, options = {}) {
+  const route = input.route ?? "unknown";
+  const method = normalizeMethod(input.method);
+  const baseContext = {
+    headers: captureAllowedHeaders(input.headers),
+    ...method === void 0 ? {} : { method },
+    queryParams: extractQueryParams(route),
+    route: extractRoute(route)
+  };
+  if (options.captureBody !== true || input.body === void 0) return baseContext;
+  return {
+    ...baseContext,
+    body: toBodyRecord(sanitizeClientData(input.body))
+  };
+}
+function prepareRequestCapture(request, context, handlerArguments, options = {}) {
+  if (isWebRequestLike(request)) return prepareWebRequestCapture(request, options);
+  const requestRecord = asRecord(request);
+  const contextRecord = asRecord(context);
+  const route = readString(requestRecord, "path") ?? readString(contextRecord, "routePath") ?? "server-action";
+  const method = readString(requestRecord, "method");
+  const normalizedMethod = normalizeMethod(method);
+  const framework = captureNextFrameworkContext(contextRecord);
+  const baseSnapshot = {
+    ...framework === void 0 ? {} : { framework },
+    headers: captureAllowedHeaders(readUnknown(requestRecord, "headers")),
+    ...normalizedMethod === void 0 ? {} : { method: normalizedMethod },
+    queryParams: extractQueryParams(route),
+    route: extractRoute(route)
+  };
+  if (options.captureBody !== true || handlerArguments === void 0) {
+    return () => Promise.resolve(baseSnapshot);
+  }
+  const body = toBodyRecord(sanitizeClientData({ arguments: handlerArguments }));
+  const snapshot = { ...baseSnapshot, body };
+  return () => Promise.resolve(snapshot);
+}
+function prepareWebRequestCapture(request, options) {
+  const method = normalizeMethod(request.method);
+  const baseContext = {
+    headers: captureAllowedHeaders(request.headers),
+    ...method === void 0 ? {} : { method },
+    queryParams: extractQueryParams(request.url),
+    route: extractRoute(request.url)
+  };
+  if (options.captureBody !== true || method === "GET" || method === "HEAD") {
+    return () => Promise.resolve(baseContext);
+  }
+  const declaredContentLength = readHeader(request.headers, "content-length");
+  if (declaredContentLength !== void 0 && Number(declaredContentLength) > MAX_CAPTURED_BODY_BYTES) {
+    return () => Promise.resolve({
+      ...baseContext,
+      body: { value: "[BODY_OMITTED_SIZE_LIMIT]" }
+    });
+  }
+  const clonedRequest = safeClone(request);
+  if (clonedRequest === void 0) return () => Promise.resolve(baseContext);
+  return async () => {
+    const body = await readRequestBody(clonedRequest);
+    return body === void 0 ? baseContext : { ...baseContext, body };
+  };
+}
+async function readRequestBody(request) {
+  const contentLength = readHeader(request.headers, "content-length");
+  if (contentLength !== void 0 && Number(contentLength) > MAX_CAPTURED_BODY_BYTES) {
+    cancelReadableBody(request.body, "KYNCODE body capture declared size limit");
+    return { value: "[BODY_OMITTED_SIZE_LIMIT]" };
+  }
+  const body = request.body;
+  if (body === null || body === void 0) return void 0;
+  if (!hasBodyReader(body)) {
+    cancelReadableBody(body, "KYNCODE body capture received an unreadable clone");
+    return void 0;
+  }
+  const bytes = await readBoundedBody(body);
+  if (bytes === "limit") return { value: "[BODY_OMITTED_SIZE_LIMIT]" };
+  if (bytes === void 0 || bytes.byteLength === 0) return void 0;
+  const text = new TextDecoder().decode(bytes);
+  const contentType = readHeader(request.headers, "content-type")?.toLowerCase() ?? "";
+  if (contentType.includes("application/json") || contentType.includes("+json")) {
+    try {
+      const parsed = JSON.parse(text);
+      return toBodyRecord(sanitizeClientData(parsed));
+    } catch {
+      return { value: "[INVALID_JSON_BODY]" };
+    }
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    return toBodyRecord(sanitizeClientData(Object.fromEntries(new URLSearchParams(text))));
+  }
+  return { value: "[BODY_OMITTED_UNSUPPORTED_CONTENT_TYPE]" };
+}
+function captureAllowedHeaders(value) {
+  const headers = normalizeHeaderRecord(value);
+  const allowed = Object.fromEntries(
+    Object.entries(headers).filter(([key]) => ALLOWED_HEADER_NAMES.has(key.toLowerCase()))
+  );
+  return sanitizeStringRecord(allowed);
+}
+function normalizeHeaderRecord(value) {
+  const entries = readHeaderEntries(value);
+  if (entries !== void 0) return Object.fromEntries(entries);
+  const record = asRecord(value);
+  if (record === void 0) return {};
+  return Object.fromEntries(
+    safeObjectEntries(record).flatMap(([key, headerValue]) => {
+      if (typeof headerValue === "string") return [[key.toLowerCase(), headerValue]];
+      if (Array.isArray(headerValue) && headerValue.every((item) => typeof item === "string")) {
+        return [[key.toLowerCase(), headerValue.join(", ")]];
+      }
+      return [];
+    })
+  );
+}
+function readHeaderEntries(value) {
+  const record = asRecord(value);
+  const entriesMethod = record?.["entries"];
+  if (typeof entriesMethod !== "function") return void 0;
+  try {
+    const rawEntries = Reflect.apply(entriesMethod, value, []);
+    if (!isIterable(rawEntries)) return void 0;
+    const entries = [];
+    for (const entry of rawEntries) {
+      if (Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "string") {
+        entries.push([entry[0].toLowerCase(), entry[1]]);
+      }
+    }
+    return entries;
+  } catch {
+    return void 0;
+  }
+}
+function extractRoute(value) {
+  if (value === "server-action" || value === "unknown") return value;
+  try {
+    return sanitizeText(new URL(value, "https://sdk.kyncode.invalid").pathname);
+  } catch {
+    return sanitizeText(value.split("?")[0] ?? value);
+  }
+}
+function extractQueryParams(value) {
+  try {
+    const url = new URL(value, "https://sdk.kyncode.invalid");
+    return sanitizeStringRecord(
+      Object.fromEntries(
+        [...url.searchParams.keys()].map((key) => [key, REDACTED_QUERY_VALUE])
+      )
+    );
+  } catch {
+    return {};
+  }
+}
+function normalizeMethod(value) {
+  const candidate = value?.toUpperCase();
+  return candidate !== void 0 && VALID_METHODS.has(candidate) ? candidate : void 0;
+}
+function captureNextFrameworkContext(context) {
+  if (context === void 0) return void 0;
+  const routePath = readString(context, "routePath");
+  const routeType = readString(context, "routeType");
+  const routerKind = readString(context, "routerKind");
+  const renderSource = readString(context, "renderSource");
+  if (routePath === void 0 && routeType === void 0 && routerKind === void 0 && renderSource === void 0)
+    return void 0;
+  return {
+    name: "nextjs",
+    ...renderSource === void 0 ? {} : { renderSource: sanitizeText(renderSource) },
+    ...routePath === void 0 ? {} : { routePath: sanitizeText(routePath) },
+    ...routeType === void 0 ? {} : { routeType: sanitizeText(routeType) },
+    ...routerKind === void 0 ? {} : { routerKind: sanitizeText(routerKind) }
+  };
+}
+function toBodyRecord(value) {
+  return isPlainRecord(value) ? value : { value };
+}
+function asRecord(value) {
+  return isPlainRecord(value) ? value : void 0;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(record, key) {
+  const value = readUnknown(record, key);
+  return typeof value === "string" ? value : void 0;
+}
+function readUnknown(record, key) {
+  try {
+    return record?.[key];
+  } catch {
+    return void 0;
+  }
+}
+function safeObjectEntries(record) {
+  try {
+    return Object.entries(record);
+  } catch {
+    return [];
+  }
+}
+function isWebRequestLike(value) {
+  const record = asRecord(value);
+  return typeof readUnknown(record, "url") === "string" && typeof readUnknown(record, "method") === "string";
+}
+function safeClone(request) {
+  if (typeof request.clone !== "function") return void 0;
+  try {
+    const clone = request.clone.call(request);
+    if (isWebRequestLike(clone)) return clone;
+    cancelReadableBody(
+      readUnknown(asRecord(clone), "body"),
+      "KYNCODE body capture received an invalid clone"
+    );
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readHeader(headers, name) {
+  return normalizeHeaderRecord(headers)[name];
+}
+async function readBoundedBody(body) {
+  let reader;
+  try {
+    reader = body.getReader();
+  } catch {
+    cancelReadableBody(body, "KYNCODE body capture could not acquire a reader");
+    return void 0;
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  const deadline = Date.now() + BODY_CAPTURE_TIMEOUT_MS;
+  try {
+    while (Date.now() < deadline) {
+      const remainingMs = Math.max(1, deadline - Date.now());
+      const result = await readWithin(reader, remainingMs);
+      if (result === void 0) {
+        cancelReader(reader, "KYNCODE body capture timeout");
+        return void 0;
+      }
+      if (result.done) return concatenateBytes(chunks, totalBytes);
+      const chunk = toByteChunk(result.value);
+      if (chunk === void 0) {
+        cancelReader(reader, "KYNCODE body capture received a non-byte chunk");
+        return void 0;
+      }
+      totalBytes += chunk.byteLength;
+      if (totalBytes > MAX_CAPTURED_BODY_BYTES) {
+        cancelReader(reader, "KYNCODE body capture size limit");
+        return "limit";
+      }
+      chunks.push(chunk);
+    }
+    cancelReader(reader, "KYNCODE body capture timeout");
+    return void 0;
+  } catch {
+    cancelReader(reader, "KYNCODE body capture failed");
+    return void 0;
+  }
+}
+async function readWithin(reader, timeoutMs) {
+  let timeoutId;
+  const timeout = new Promise((resolve) => {
+    timeoutId = setTimeout(() => {
+      resolve(void 0);
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([reader.read(), timeout]);
+  } finally {
+    if (timeoutId !== void 0) clearTimeout(timeoutId);
+  }
+}
+function cancelReader(reader, reason) {
+  try {
+    const cancellation = reader.cancel(reason);
+    if (cancellation !== void 0) void cancellation.catch(() => void 0);
+  } catch {
+  }
+}
+function cancelReadableBody(body, reason) {
+  const record = asRecord(body);
+  const cancel = readUnknown(record, "cancel");
+  if (typeof cancel !== "function") return;
+  try {
+    const cancellation = Reflect.apply(cancel, body, [reason]);
+    if (isPromiseLike(cancellation)) {
+      void Promise.resolve(cancellation).catch(() => void 0);
+    }
+  } catch {
+  }
+}
+function concatenateBytes(chunks, totalBytes) {
+  const result = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+function toByteChunk(value) {
+  if (!ArrayBuffer.isView(value)) return void 0;
+  return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+}
+function isIterable(value) {
+  if (typeof value !== "object" || value === null) return false;
+  try {
+    return Symbol.iterator in value;
+  } catch {
+    return false;
+  }
+}
+function hasBodyReader(value) {
+  const record = asRecord(value);
+  return typeof readUnknown(record, "getReader") === "function";
+}
+function isPromiseLike(value) {
+  if (typeof value !== "object" || value === null) return false;
+  try {
+    return typeof value["then"] === "function";
+  } catch {
+    return false;
+  }
+}
+
+// src/adapters/express.ts
+function createExpressErrorHandler(capture, shouldCaptureBody = () => false) {
+  return (error, request, response, next) => {
+    void response;
+    try {
+      capture(
+        error,
+        captureStructuredRequest(
+          {
+            ...request.body === void 0 ? {} : { body: request.body },
+            ...request.headers === void 0 ? {} : { headers: request.headers },
+            ...request.method === void 0 ? {} : { method: request.method },
+            route: request.originalUrl ?? request.url ?? "unknown"
+          },
+          { captureBody: shouldCaptureBody() }
+        ),
+        "express"
+      );
+    } catch {
+    }
+    next(error);
+  };
+}
+
+// src/adapters/fastify.ts
+function createFastifyErrorHandler(capture, shouldCaptureBody = () => false) {
+  return (error, request, reply) => {
+    try {
+      capture(
+        error,
+        captureStructuredRequest(
+          {
+            ...request.body === void 0 ? {} : { body: request.body },
+            ...request.headers === void 0 && request.raw?.headers === void 0 ? {} : { headers: request.headers ?? request.raw?.headers },
+            ...request.method === void 0 ? {} : { method: request.method },
+            route: request.raw?.url ?? request.url ?? "unknown"
+          },
+          { captureBody: shouldCaptureBody() }
+        ),
+        "fastify"
+      );
+    } catch {
+    }
+    return reply.send(error);
+  };
+}
+
+// src/adapters/node.ts
+function registerNodeProcessListeners(capture) {
+  const onUncaughtExceptionMonitor = (error, origin) => {
+    captureProcessError(capture, error, origin);
+  };
+  process.on("uncaughtExceptionMonitor", onUncaughtExceptionMonitor);
+  return () => {
+    process.off("uncaughtExceptionMonitor", onUncaughtExceptionMonitor);
+  };
+}
+function captureProcessError(capture, error, eventName) {
+  try {
+    capture(
+      error,
+      {
+        headers: {},
+        queryParams: {},
+        route: `/process/${eventName}`
+      },
+      "node"
+    );
+  } catch {
+  }
+}
+
+// src/dispatch.ts
+var DISPATCH_TIMEOUT_MS = 2e3;
+var MAX_PAYLOAD_BYTES = 64 * 1024;
+var MAX_PENDING_EVENTS = 100;
+var MAX_CONCURRENT_DISPATCHES = 2;
+var MAX_DISPATCHES_PER_MINUTE = 60;
+var MAX_DELIVERY_ATTEMPTS = 3;
+var STARTUP_CONNECTIVITY_TIMEOUT_MS = 500;
+var DEFAULT_FLUSH_TIMEOUT_MS = 2e3;
+var RATE_WINDOW_MS = 6e4;
+var RETRY_BASE_DELAY_MS = 100;
+var RUNTIME_REQUEST_CONTEXT_SYMBOLS = [
+  /* @__PURE__ */ Symbol.for("@vercel/request-context"),
+  /* @__PURE__ */ Symbol.for("@next/request-context")
+];
+var BoundedDispatcher = class {
+  #active = 0;
+  #pending = [];
+  #recentDispatches = [];
+  #flushWaiters = /* @__PURE__ */ new Set();
+  enqueue(payload, config, maxDeliveryAttempts = MAX_DELIVERY_ATTEMPTS) {
+    if (this.#pending.length >= MAX_PENDING_EVENTS) {
+      debug(config, "Event dropped because the bounded delivery queue is full");
+      return Promise.resolve({
+        message: "The bounded delivery queue is full",
+        ok: false,
+        status: "queue_full"
+      });
+    }
+    const serializedBody = serializePayload(payload);
+    return new Promise((resolve) => {
+      this.#pending.push({
+        config,
+        idempotencyKey: payload.eventId,
+        maxDeliveryAttempts,
+        resolve,
+        serializedBody
+      });
+      this.#pump();
+    });
+  }
+  async flush(options = {}) {
+    if (this.#isIdle()) return { completed: true, pending: 0, timedOut: false };
+    const timeoutMs = normalizeFlushTimeout(options.timeoutMs);
+    return new Promise((resolve) => {
+      let settled = false;
+      const settle = (timedOut) => {
+        if (settled) return;
+        settled = true;
+        this.#flushWaiters.delete(onIdle);
+        clearTimeout(timeoutId);
+        const pending = this.#active + this.#pending.length;
+        resolve({ completed: pending === 0, pending, timedOut });
+      };
+      const onIdle = () => {
+        settle(false);
+      };
+      const timeoutId = setTimeout(() => {
+        settle(true);
+      }, timeoutMs);
+      this.#flushWaiters.add(onIdle);
+      if (this.#isIdle()) settle(false);
+    });
+  }
+  reset() {
+    const dropped = {
+      message: "Delivery state was reset",
+      ok: false,
+      status: "failed"
+    };
+    for (const queued of this.#pending.splice(0)) queued.resolve(dropped);
+    this.#recentDispatches.splice(0);
+    this.#notifyIfIdle();
+  }
+  #pump() {
+    while (this.#active < MAX_CONCURRENT_DISPATCHES) {
+      const queued = this.#pending.shift();
+      if (queued === void 0) break;
+      if (!this.#consumeRateSlot()) {
+        queued.resolve({
+          message: "The SDK delivery rate limit was reached",
+          ok: false,
+          status: "rate_limited"
+        });
+        debug(queued.config, "Event dropped by the client-side delivery rate limit");
+        continue;
+      }
+      this.#active += 1;
+      void postSerializedJson(
+        queued.config.endpoint,
+        queued.serializedBody,
+        queued.idempotencyKey,
+        queued.config,
+        queued.maxDeliveryAttempts
+      ).then(queued.resolve).finally(() => {
+        this.#active -= 1;
+        this.#pump();
+        this.#notifyIfIdle();
+      });
+    }
+    this.#notifyIfIdle();
+  }
+  #consumeRateSlot() {
+    const now = Date.now();
+    while ((this.#recentDispatches[0] ?? now) <= now - RATE_WINDOW_MS) {
+      this.#recentDispatches.shift();
+    }
+    if (this.#recentDispatches.length >= MAX_DISPATCHES_PER_MINUTE) return false;
+    this.#recentDispatches.push(now);
+    return true;
+  }
+  #isIdle() {
+    return this.#active === 0 && this.#pending.length === 0;
+  }
+  #notifyIfIdle() {
+    if (!this.#isIdle()) return;
+    for (const waiter of [...this.#flushWaiters]) waiter();
+  }
+};
+var dispatcher = new BoundedDispatcher();
+function dispatchInBackground(payload, config) {
+  const delivery = dispatcher.enqueue(payload, config);
+  void scheduleWithRuntime(delivery, config);
+}
+async function dispatchWithRuntime(payload, config) {
+  const waitUntil = resolveRuntimeWaitUntil();
+  if (waitUntil === void 0) {
+    debug(config, "Runtime waitUntil unavailable; using one bounded delivery attempt");
+    await Promise.allSettled([dispatcher.enqueue(payload, config, 1)]);
+    return;
+  }
+  let settleRuntimeDelivery = () => void 0;
+  const runtimeDelivery = new Promise((resolve) => {
+    settleRuntimeDelivery = resolve;
+  });
+  try {
+    waitUntil(runtimeDelivery);
+  } catch (error) {
+    settleRuntimeDelivery();
+    debug(config, "Runtime waitUntil rejected delivery; using one bounded delivery attempt", error);
+    await Promise.allSettled([dispatcher.enqueue(payload, config, 1)]);
+    return;
+  }
+  void dispatcher.enqueue(payload, config).then(() => {
+    settleRuntimeDelivery();
+  });
+}
+function dispatchAndWait(payload, config) {
+  return dispatcher.enqueue(payload, config);
+}
+async function dispatchConnectivity(config, runtime, sdkVersion) {
+  const idempotencyKey = `connect_${createRandomIdentifier()}`;
+  const serializedBody = serializeConnectivity(runtime, sdkVersion);
+  return postSerializedJson(
+    connectivityEndpoint(config.endpoint),
+    serializedBody,
+    idempotencyKey,
+    config
+  );
+}
+function dispatchStartupConnectivity(config, runtime, sdkVersion) {
+  return postOnce(
+    connectivityEndpoint(config.endpoint),
+    serializeConnectivity(runtime, sdkVersion),
+    `connect_${createRandomIdentifier()}`,
+    config,
+    STARTUP_CONNECTIVITY_TIMEOUT_MS
+  );
+}
+function flushDispatches(options) {
+  return dispatcher.flush(options);
+}
+function resetDispatchState() {
+  dispatcher.reset();
+}
+async function scheduleWithRuntime(dispatchPromise, config) {
+  try {
+    const waitUntil = resolveRuntimeWaitUntil();
+    if (waitUntil === void 0) throw new Error("waitUntil is unavailable");
+    waitUntil(dispatchPromise);
+  } catch (error) {
+    debug(config, "Runtime waitUntil unavailable; using the bounded Node queue", error);
+    await Promise.allSettled([dispatchPromise]);
+  }
+}
+function resolveRuntimeWaitUntil() {
+  for (const contextSymbol of RUNTIME_REQUEST_CONTEXT_SYMBOLS) {
+    try {
+      const globalRecord = globalThis;
+      const accessor = globalRecord[contextSymbol];
+      if (typeof accessor !== "object" || accessor === null) continue;
+      const get = accessor["get"];
+      if (typeof get !== "function") continue;
+      const context = get.call(accessor);
+      if (typeof context !== "object" || context === null) continue;
+      const waitUntil = context["waitUntil"];
+      if (typeof waitUntil !== "function") continue;
+      return (promise) => {
+        void waitUntil.call(context, promise);
+      };
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function postSerializedJson(endpoint, serializedBody, idempotencyKey, config, maxDeliveryAttempts = MAX_DELIVERY_ATTEMPTS) {
+  let lastOutcome = {
+    message: "KYNCODE dispatch failed safely",
+    ok: false,
+    status: "failed"
+  };
+  for (let attempt = 1; attempt <= maxDeliveryAttempts; attempt += 1) {
+    lastOutcome = await postOnce(endpoint, serializedBody, idempotencyKey, config);
+    if (lastOutcome.ok || !isRetryable(lastOutcome) || attempt === maxDeliveryAttempts) {
+      return lastOutcome;
+    }
+    await delay(RETRY_BASE_DELAY_MS * attempt);
+  }
+  return lastOutcome;
+}
+async function postOnce(endpoint, serializedBody, idempotencyKey, config, timeoutMs = DISPATCH_TIMEOUT_MS) {
+  const controller = new AbortController();
+  let timeoutId;
+  const timeout = new Promise((resolve) => {
+    timeoutId = setTimeout(() => {
+      controller.abort();
+      resolve(void 0);
+    }, timeoutMs);
+  });
+  try {
+    const response = await Promise.race([
+      fetch(endpoint, {
+        body: serializedBody,
+        credentials: "omit",
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "Content-Type": "application/json",
+          "Idempotency-Key": idempotencyKey
+        },
+        method: "POST",
+        redirect: "error",
+        referrerPolicy: "no-referrer",
+        signal: controller.signal
+      }),
+      timeout
+    ]);
+    if (response === void 0) {
+      const message = `KYNCODE dispatch timed out after ${String(timeoutMs)}ms`;
+      debug(config, message);
+      return { message, ok: false, status: "failed" };
+    }
+    cancelResponseBody(response);
+    if (!response.ok) {
+      debug(config, `KYNCODE ingestion returned HTTP ${String(response.status)}`);
+      return {
+        httpStatus: response.status,
+        message: `KYNCODE ingestion returned HTTP ${String(response.status)}`,
+        ok: false,
+        status: response.status === 429 ? "rate_limited" : "failed"
+      };
+    }
+    return {
+      httpStatus: response.status,
+      message: "Event delivered to KYNCODE",
+      ok: true,
+      status: "sent"
+    };
+  } catch (error) {
+    const message = controller.signal.aborted ? `KYNCODE dispatch timed out after ${String(timeoutMs)}ms` : "KYNCODE dispatch failed safely";
+    debug(config, message, error);
+    return { message, ok: false, status: "failed" };
+  } finally {
+    if (timeoutId !== void 0) clearTimeout(timeoutId);
+  }
+}
+function serializeConnectivity(runtime, sdkVersion) {
+  return JSON.stringify({ runtime, sdk: "@kyncode/sdk", sdkVersion });
+}
+function serializePayload(payload) {
+  const serialized = JSON.stringify(payload);
+  if (byteLength(serialized) <= MAX_PAYLOAD_BYTES) return serialized;
+  const compactPayload = {
+    ...payload,
+    context: {
+      ...payload.context.framework === void 0 ? {} : { framework: payload.context.framework },
+      headers: payload.context.headers,
+      ...payload.context.method === void 0 ? {} : { method: payload.context.method },
+      queryParams: {},
+      route: payload.context.route
+    },
+    error: {
+      ...payload.error.digest === void 0 ? {} : { digest: payload.error.digest },
+      message: payload.error.message,
+      name: payload.error.name,
+      stack: payload.error.stack
+    },
+    metadata: {
+      ...payload.metadata ?? {},
+      payloadTruncated: "true",
+      truncationReason: "payload_size_limit"
+    }
+  };
+  const compact = JSON.stringify(compactPayload);
+  if (byteLength(compact) <= MAX_PAYLOAD_BYTES) return compact;
+  const minimalPayload = {
+    context: {
+      headers: {},
+      ...compactPayload.context.method === void 0 ? {} : { method: compactPayload.context.method },
+      queryParams: {},
+      route: compactPayload.context.route.slice(0, 1024)
+    },
+    environment: compactPayload.environment,
+    error: {
+      message: compactPayload.error.message.slice(0, 1024),
+      name: compactPayload.error.name.slice(0, 128),
+      stack: compactPayload.error.stack.slice(0, 4096)
+    },
+    eventId: compactPayload.eventId,
+    ...compactPayload.runtime === void 0 ? {} : { runtime: compactPayload.runtime },
+    sdkVersion: compactPayload.sdkVersion,
+    source: "sdk_code",
+    timestamp: compactPayload.timestamp
+  };
+  const minimal = JSON.stringify(minimalPayload);
+  if (byteLength(minimal) <= MAX_PAYLOAD_BYTES) return minimal;
+  return JSON.stringify({
+    ...minimalPayload,
+    context: {
+      headers: {},
+      ...minimalPayload.context.method === void 0 ? {} : { method: minimalPayload.context.method },
+      queryParams: {},
+      route: "unknown"
+    },
+    error: {
+      message: "Application error exceeded the SDK payload limit",
+      name: "Error",
+      stack: "Error details omitted by the SDK payload limit"
+    }
+  });
+}
+function connectivityEndpoint(ingestionEndpoint) {
+  const endpoint = new URL(ingestionEndpoint);
+  endpoint.pathname = "/v1/telemetry/ping";
+  endpoint.search = "";
+  endpoint.hash = "";
+  return endpoint.toString();
+}
+function normalizeFlushTimeout(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.min(Math.floor(value), 3e4) : DEFAULT_FLUSH_TIMEOUT_MS;
+}
+function isRetryable(outcome) {
+  if (outcome.ok) return false;
+  if (outcome.httpStatus === void 0) return true;
+  return outcome.httpStatus === 408 || outcome.httpStatus === 425 || outcome.httpStatus === 429 || outcome.httpStatus >= 500;
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+function createRandomIdentifier() {
+  try {
+    if (typeof globalThis.crypto.randomUUID === "function") return globalThis.crypto.randomUUID();
+  } catch {
+  }
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+}
+function cancelResponseBody(response) {
+  try {
+    const cancellation = response.body?.cancel();
+    if (cancellation !== void 0) void cancellation.catch(() => void 0);
+  } catch {
+  }
+}
+function byteLength(value) {
+  if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(value).byteLength;
+  return value.length;
+}
+function debug(config, message, detail) {
+  if (!config.debug) return;
+  const detailMessage = readErrorMessage(detail);
+  console.debug(
+    `[KYNCODE SDK] ${sanitizeText(message)}`,
+    detailMessage === void 0 ? "" : sanitizeText(detailMessage)
+  );
+}
+function readErrorMessage(value) {
+  if (typeof value === "string") return value;
+  if (typeof value !== "object" || value === null) return void 0;
+  try {
+    const message = value["message"];
+    return typeof message === "string" ? message : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/loly.ts
+var SDK_VERSION = true ? "0.1.0" : "0.1.0";
+var DEFAULT_ENDPOINT = "https://api.kyncode.com/v1/ingest";
+var LIVE_API_KEY_PATTERN = /^kyn_live_[a-f0-9]{64}$/u;
+var DEDUPE_WINDOW_MS = 5e3;
+var MAX_PRIMITIVE_DEDUPE_ENTRIES = 256;
+var LolyClient = class {
+  #configOverrides = {};
+  #processEventCleanup;
+  #recentErrors = /* @__PURE__ */ new WeakMap();
+  #recentPrimitiveErrors = /* @__PURE__ */ new Map();
+  init = (config = {}) => {
+    enableRuntimeSourceMaps();
+    this.#configOverrides = { ...config };
+    this.#recentErrors = /* @__PURE__ */ new WeakMap();
+    this.#recentPrimitiveErrors.clear();
+    if (readEnvironment("NODE_ENV") === "test") resetDispatchState();
+  };
+  connect = async (runtime = "Node.js") => {
+    enableRuntimeSourceMaps();
+    const config = this.#resolveConfig();
+    const unavailable = this.#connectConfigurationDiagnostic(config, runtime);
+    if (unavailable !== void 0) return unavailable;
+    const outcome = await dispatchConnectivity(
+      { apiKey: config.apiKey, debug: config.debug, endpoint: config.endpoint },
+      runtime,
+      SDK_VERSION
+    );
+    return connectivityDiagnosticFromOutcome(runtime, outcome);
+  };
+  connectForStartup = async (runtime) => {
+    enableRuntimeSourceMaps();
+    const config = this.#resolveConfig();
+    const unavailable = this.#connectConfigurationDiagnostic(config, runtime);
+    if (unavailable !== void 0) return unavailable;
+    const outcome = await dispatchStartupConnectivity(
+      { apiKey: config.apiKey, debug: config.debug, endpoint: config.endpoint },
+      runtime,
+      SDK_VERSION
+    );
+    return connectivityDiagnosticFromOutcome(runtime, outcome);
+  };
+  expressErrorHandler = () => createExpressErrorHandler(
+    (error, requestContext, runtime) => {
+      this.#captureSafely(error, requestContext, runtime);
+    },
+    () => this.#resolveConfig().captureBody
+  );
+  fastifyErrorHandler = () => createFastifyErrorHandler(
+    (error, requestContext, runtime) => {
+      this.#captureSafely(error, requestContext, runtime);
+    },
+    () => this.#resolveConfig().captureBody
+  );
+  flush = (options) => flushDispatches(options);
+  listenToProcessEvents = () => {
+    if (this.#processEventCleanup !== void 0) return this.#processEventCleanup;
+    const unregister = registerNodeProcessListeners((error, requestContext, runtime) => {
+      this.#captureSafely(error, requestContext, runtime);
+    });
+    const cleanup = () => {
+      unregister();
+      if (this.#processEventCleanup === cleanup) this.#processEventCleanup = void 0;
+    };
+    this.#processEventCleanup = cleanup;
+    return cleanup;
+  };
+  shield = (handler) => {
+    return async (...arguments_) => {
+      const config = this.#resolveConfig();
+      const captureRequest = this.#prepareRequestSafely(arguments_, config.captureBody);
+      try {
+        return await handler(...arguments_);
+      } catch (error) {
+        if (this.#canSend(config) && this.#reserveError(error)) {
+          scheduleMicrotask(() => {
+            void captureRequest().catch((captureError) => {
+              this.#debug(config, "Request capture failed safely", captureError);
+              return createFallbackRequestContext();
+            }).then((requestContext) => {
+              this.#captureReserved(error, requestContext, config);
+            });
+          });
+        }
+        throw error;
+      }
+    };
+  };
+  captureGlobalError = async (error, request, context) => {
+    const config = this.#resolveConfig();
+    if (!this.#canSend(config) || !this.#reserveError(error)) return;
+    const requestContext = await this.#captureGlobalRequestContext(request, context, config);
+    try {
+      const runtime = requestContext.framework?.name === "nextjs" ? "nextjs" : void 0;
+      const payload = this.#preparePayload(error, requestContext, config.environment, runtime);
+      await dispatchAndWait(payload, toDispatchConfig(config));
+    } catch (captureError) {
+      this.#debug(config, "Global error dispatch failed safely", captureError);
+    }
+  };
+  captureGlobalErrorForInstrumentation = async (error, request, context) => {
+    const config = this.#resolveConfig();
+    if (!this.#canSend(config) || !this.#reserveError(error)) return;
+    const requestContext = await this.#captureGlobalRequestContext(request, context, config);
+    try {
+      const runtime = requestContext.framework?.name === "nextjs" ? "nextjs" : void 0;
+      const payload = this.#preparePayload(error, requestContext, config.environment, runtime);
+      await dispatchWithRuntime(payload, toDispatchConfig(config));
+    } catch (captureError) {
+      this.#debug(config, "Global instrumentation dispatch failed safely", captureError);
+    }
+  };
+  async #captureGlobalRequestContext(request, context, config) {
+    try {
+      return await prepareRequestCapture(request, context, void 0, {
+        captureBody: config.captureBody
+      })();
+    } catch (captureError) {
+      this.#debug(config, "Global error capture failed safely", captureError);
+      return createFallbackRequestContext();
+    }
+  }
+  #prepareRequestSafely(arguments_, captureBody) {
+    try {
+      return prepareRequestCapture(arguments_[0], arguments_[1], arguments_, { captureBody });
+    } catch {
+      return () => Promise.resolve(createFallbackRequestContext());
+    }
+  }
+  #captureSafely(error, requestContext, runtime) {
+    const config = this.#resolveConfig();
+    if (!this.#canSend(config) || !this.#reserveError(error)) return;
+    this.#captureReserved(error, requestContext, config, runtime);
+  }
+  #captureReserved(error, requestContext, config, runtime) {
+    try {
+      const payload = this.#preparePayload(error, requestContext, config.environment, runtime);
+      dispatchInBackground(payload, toDispatchConfig(config));
+    } catch (captureError) {
+      this.#debug(config, "Error normalization failed safely", captureError);
+    }
+  }
+  #preparePayload(error, requestContext, environment, runtime) {
+    const basePayload = {
+      context: requestContext,
+      environment,
+      error: normalizeError(error),
+      eventId: createEventId(),
+      sdkVersion: SDK_VERSION,
+      source: "sdk_code",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return runtime === void 0 ? basePayload : { ...basePayload, runtime };
+  }
+  #reserveError(error) {
+    const now = Date.now();
+    if (typeof error === "object" && error !== null) {
+      const capturedAt2 = this.#recentErrors.get(error);
+      if (capturedAt2 !== void 0 && now - capturedAt2 < DEDUPE_WINDOW_MS) return false;
+      this.#recentErrors.set(error, now);
+      return true;
+    }
+    for (const [fingerprint2, capturedAt2] of this.#recentPrimitiveErrors) {
+      if (now - capturedAt2 >= DEDUPE_WINDOW_MS) this.#recentPrimitiveErrors.delete(fingerprint2);
+    }
+    const fingerprint = `${typeof error}:${sanitizeText(String(error))}`;
+    const capturedAt = this.#recentPrimitiveErrors.get(fingerprint);
+    if (capturedAt !== void 0 && now - capturedAt < DEDUPE_WINDOW_MS) return false;
+    if (this.#recentPrimitiveErrors.size >= MAX_PRIMITIVE_DEDUPE_ENTRIES) {
+      const oldest = this.#recentPrimitiveErrors.keys().next().value;
+      if (typeof oldest === "string") this.#recentPrimitiveErrors.delete(oldest);
+    }
+    this.#recentPrimitiveErrors.set(fingerprint, now);
+    return true;
+  }
+  #canSend(config) {
+    if (!config.enabled) {
+      this.#debug(config, "SDK capture is disabled; event was not sent");
+      return false;
+    }
+    if (!LIVE_API_KEY_PATTERN.test(config.apiKey)) {
+      this.#debug(config, "KYNCODE_API_KEY is missing or invalid; event was not sent");
+      return false;
+    }
+    return true;
+  }
+  #connectConfigurationDiagnostic(config, runtime) {
+    if (!config.enabled) {
+      return {
+        message: "KYNCODE SDK is disabled in this runtime",
+        ok: false,
+        runtime,
+        status: "disabled"
+      };
+    }
+    if (!LIVE_API_KEY_PATTERN.test(config.apiKey)) {
+      return {
+        message: "KYNCODE_API_KEY is missing or invalid",
+        ok: false,
+        runtime,
+        status: "invalid_api_key"
+      };
+    }
+    return void 0;
+  }
+  #resolveConfig() {
+    return resolveConfig(this.#configOverrides);
+  }
+  #debug(config, message, detail) {
+    if (!config.debug) return;
+    console.debug(
+      `[KYNCODE SDK] ${sanitizeText(message)}`,
+      detail === void 0 ? "" : sanitizeText(readErrorMessage2(detail) ?? "Unknown diagnostic")
+    );
+  }
+};
+var lolyClient = new LolyClient();
+var Loly = lolyClient;
+var onRequestError = (error, request, context) => lolyClient.captureGlobalErrorForInstrumentation(error, request, context);
+var register = async () => {
+  enableRuntimeSourceMaps();
+  await lolyClient.connectForStartup("Next.js instrumentation");
+};
+function enableRuntimeSourceMaps() {
+  const processValue = globalThis.process;
+  if (processValue === null || typeof processValue !== "object") return;
+  const setter = processValue["setSourceMapsEnabled"];
+  if (typeof setter !== "function") return;
+  try {
+    Reflect.apply(setter, processValue, [true]);
+  } catch {
+  }
+}
+function resolveConfig(config) {
+  const nodeEnvironment = readEnvironment("NODE_ENV");
+  const environment = config.environment ?? resolveNodeEnvironment(nodeEnvironment);
+  const enabled = config.enabled ?? readBooleanEnvironment("KYNCODE_SDK_ENABLED") ?? nodeEnvironment !== "test";
+  return {
+    apiKey: config.apiKey ?? readEnvironment("KYNCODE_API_KEY") ?? "",
+    captureBody: config.captureBody ?? readBooleanEnvironment("KYNCODE_CAPTURE_REQUEST_BODY") ?? false,
+    debug: config.debug ?? readBooleanEnvironment("KYNCODE_DEBUG") ?? false,
+    enabled,
+    endpoint: DEFAULT_ENDPOINT,
+    environment
+  };
+}
+function resolveNodeEnvironment(value) {
+  return value === "development" || value === "staging" || value === "production" ? value : "production";
+}
+function normalizeError(error) {
+  const errorRecord = asRecord2(error);
+  const rawMessage = readString2(errorRecord, "message") ?? (typeof error === "string" ? error : "Unknown application error");
+  const message = nonEmptySanitized(rawMessage, "Unknown application error");
+  const name = nonEmptySanitized(readString2(errorRecord, "name") ?? "Error", "Error");
+  const rawStack = readString2(errorRecord, "stack") ?? new Error(message).stack ?? `${name}: ${message}`;
+  const stack = nonEmptySanitized(rawStack, `${name}: ${message}`);
+  const rawDigest = readString2(errorRecord, "digest");
+  const normalized = { message, name, stack };
+  if (rawDigest === void 0) return normalized;
+  const digest = sanitizeText(rawDigest);
+  return digest === "" ? normalized : { ...normalized, digest };
+}
+function createFallbackRequestContext() {
+  return { headers: {}, queryParams: {}, route: "unknown" };
+}
+function asRecord2(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function readString2(record, key) {
+  try {
+    const value = record?.[key];
+    return typeof value === "string" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function nonEmptySanitized(value, fallback) {
+  const sanitized = sanitizeText(value).trim();
+  return sanitized === "" ? fallback : sanitized;
+}
+function readEnvironment(name) {
+  try {
+    return typeof process === "undefined" ? void 0 : process.env[name];
+  } catch {
+    return void 0;
+  }
+}
+function readBooleanEnvironment(name) {
+  const value = readEnvironment(name)?.trim().toLowerCase();
+  if (value === "true" || value === "1") return true;
+  if (value === "false" || value === "0") return false;
+  return void 0;
+}
+function toDispatchConfig(config) {
+  return { apiKey: config.apiKey, debug: config.debug, endpoint: config.endpoint };
+}
+function createEventId() {
+  try {
+    if (typeof globalThis.crypto.randomUUID === "function") {
+      return `evt_${globalThis.crypto.randomUUID().replaceAll("-", "")}`;
+    }
+  } catch {
+  }
+  return `evt_${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}
+function scheduleMicrotask(callback) {
+  if (typeof queueMicrotask === "function") {
+    queueMicrotask(callback);
+    return;
+  }
+  void Promise.resolve().then(callback);
+}
+function connectivityDiagnosticFromOutcome(runtime, outcome) {
+  if (outcome.ok) {
+    return {
+      ...outcome.httpStatus === void 0 ? {} : { httpStatus: outcome.httpStatus },
+      message: "KYNCODE connectivity verified",
+      ok: true,
+      runtime,
+      status: "connected"
+    };
+  }
+  const credentialsRejected = outcome.httpStatus === 401 || outcome.httpStatus === 403;
+  return {
+    ...outcome.httpStatus === void 0 ? {} : { httpStatus: outcome.httpStatus },
+    message: outcome.message,
+    ok: false,
+    runtime,
+    status: credentialsRejected ? "invalid_api_key" : outcome.status === "rate_limited" ? "rate_limited" : "failed"
+  };
+}
+function readErrorMessage2(value) {
+  if (typeof value === "string") return value;
+  return readString2(asRecord2(value), "message");
+}
+
+// src/index.ts
+var index_default = Loly;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Loly,
+  SDK_VERSION,
+  onRequestError,
+  register
+});
+//# sourceMappingURL=index.cjs.map