@kanca-app/ikas 0.1.1

package/dist/index.cjs

@@ -0,0 +1,803 @@
+"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 src_exports = {};
+__export(src_exports, {
+  SDK_NAME: () => SDK_NAME,
+  SDK_VERSION: () => SDK_VERSION,
+  UNINSTALL_SCOPES: () => UNINSTALL_SCOPES,
+  createKanca: () => createKanca,
+  operationName: () => operationName
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/graphql.ts
+function lex(src) {
+  const out = [];
+  let i = 0;
+  const n = src.length;
+  while (i < n) {
+    const c = src[i];
+    if (c === "#") {
+      while (i < n && src[i] !== "\n" && src[i] !== "\r") i++;
+      continue;
+    }
+    if (c === '"') {
+      if (src.startsWith('"""', i)) {
+        const end = src.indexOf('"""', i + 3);
+        i = end === -1 ? n : end + 3;
+      } else {
+        i++;
+        while (i < n && src[i] !== '"' && src[i] !== "\n") i += src[i] === "\\" ? 2 : 1;
+        i++;
+      }
+      continue;
+    }
+    if (/[A-Za-z_]/.test(c)) {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9_]/.test(src[j])) j++;
+      out.push({ t: "name", v: src.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (src.startsWith("...", i)) {
+      out.push({ t: "punct", v: "..." });
+      i += 3;
+      continue;
+    }
+    if ("{}()[]:@$!=|&".includes(c)) out.push({ t: "punct", v: c });
+    i++;
+  }
+  return out;
+}
+function skipBlock(toks, start) {
+  const open = toks[start].v;
+  const close = open === "{" ? "}" : ")";
+  let depth = 0;
+  for (let i = start; i < toks.length; i++) {
+    const v = toks[i];
+    if (v.t !== "punct") continue;
+    if (v.v === open) depth++;
+    else if (v.v === close && --depth === 0) return i + 1;
+  }
+  return toks.length;
+}
+function firstRootField(toks, start) {
+  for (let i = start + 1; i < toks.length; i++) {
+    const tk = toks[i];
+    if (tk.t === "punct") {
+      if (tk.v === "}") return void 0;
+      if (tk.v === "...") return void 0;
+      continue;
+    }
+    const next = toks[i + 1];
+    if (next && next.t === "punct" && next.v === ":") {
+      const real = toks[i + 2];
+      return real && real.t === "name" ? real.v : void 0;
+    }
+    return tk.v;
+  }
+  return void 0;
+}
+function operationName(query, requestedName) {
+  if (typeof query !== "string" || !query.trim()) return "anonymous";
+  let toks;
+  try {
+    toks = lex(query);
+  } catch {
+    return "anonymous";
+  }
+  const ops = [];
+  let i = 0;
+  while (i < toks.length) {
+    const tk = toks[i];
+    if (tk.t === "punct" && tk.v === "{") {
+      ops.push({ field: firstRootField(toks, i) });
+      i = skipBlock(toks, i);
+      continue;
+    }
+    if (tk.t === "name" && (tk.v === "query" || tk.v === "mutation" || tk.v === "subscription")) {
+      let j = i + 1;
+      let name;
+      if (toks[j]?.t === "name") name = toks[j++].v;
+      while (j < toks.length && !(toks[j].t === "punct" && toks[j].v === "{")) {
+        if (toks[j].t === "punct" && toks[j].v === "(") j = skipBlock(toks, j);
+        else j++;
+      }
+      if (j >= toks.length) {
+        ops.push({ name });
+        break;
+      }
+      ops.push({ name, field: firstRootField(toks, j) });
+      i = skipBlock(toks, j);
+      continue;
+    }
+    if (tk.t === "name" && tk.v === "fragment") {
+      let j = i + 1;
+      while (j < toks.length && !(toks[j].t === "punct" && toks[j].v === "{")) j++;
+      i = j < toks.length ? skipBlock(toks, j) : j;
+      continue;
+    }
+    i++;
+  }
+  if (!ops.length) return "anonymous";
+  let op = ops[0];
+  if (typeof requestedName === "string" && requestedName) {
+    op = ops.find((o) => o.name === requestedName) ?? op;
+  }
+  return op.name ?? op.field ?? "anonymous";
+}
+function isIkasGraphqlUrl(url) {
+  const host = url.hostname.toLowerCase();
+  if (host !== "myikas.com" && !host.endsWith(".myikas.com")) return false;
+  return url.pathname.toLowerCase().includes("graphql");
+}
+function operationNameFromBody(body) {
+  if (typeof body !== "string") return "anonymous";
+  try {
+    let parsed = JSON.parse(body);
+    if (Array.isArray(parsed)) parsed = parsed[0];
+    if (!parsed || typeof parsed !== "object") return "anonymous";
+    const p = parsed;
+    return operationName(p.query, p.operationName);
+  } catch {
+    return "anonymous";
+  }
+}
+function classifyGraphql(status, json) {
+  const payload = Array.isArray(json) ? json.find((j) => j && typeof j === "object" && Array.isArray(j.errors) && j.errors.length) ?? json[0] : json;
+  const errors = payload && typeof payload === "object" && Array.isArray(payload.errors) ? payload.errors : [];
+  const is2xx = status >= 200 && status < 300;
+  if (is2xx && errors.length === 0) return { ok: true };
+  const first = errors[0];
+  const extCode = first?.extensions?.code;
+  const code = typeof extCode === "string" && extCode ? extCode : `HTTP_${status}`;
+  const message = typeof first?.message === "string" ? first.message : void 0;
+  return { ok: false, code, message };
+}
+
+// src/shared.ts
+var SDK_NAME = "@kanca-app/ikas";
+var SDK_VERSION = "0.1.1";
+var DEFAULT_ENDPOINT = "https://kanca.onurhan.dev";
+var MAX_NAME = 200;
+var MAX_ERROR_MESSAGE = 500;
+var MAX_ERROR_CODE = 100;
+var MAX_ATTR_KEYS = 20;
+var MAX_ATTR_STRING = 500;
+var MAX_ATTR_KEY = 64;
+var MAX_EVENTS_PER_BATCH = 500;
+var MAX_BATCH_BYTES = 480 * 1024;
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max) : s;
+}
+function hex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function uuid() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  const b = new Uint8Array(16);
+  if (c && typeof c.getRandomValues === "function") c.getRandomValues(b);
+  else for (let i = 0; i < 16; i++) b[i] = Math.floor(Math.random() * 256);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = hex(b);
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function cleanAttrs(attrs) {
+  if (!attrs || typeof attrs !== "object") return void 0;
+  const out = {};
+  let n = 0;
+  for (const [k, v] of Object.entries(attrs)) {
+    if (n >= MAX_ATTR_KEYS) break;
+    if (v === void 0 || v === null || !k) continue;
+    let val;
+    if (typeof v === "boolean") val = v;
+    else if (typeof v === "number") {
+      if (!Number.isFinite(v)) continue;
+      val = v;
+    } else if (typeof v === "string") val = truncate(v, MAX_ATTR_STRING);
+    else continue;
+    out[truncate(k, MAX_ATTR_KEY)] = val;
+    n++;
+  }
+  return n > 0 ? out : void 0;
+}
+function sanitizeEvent(e) {
+  const out = {
+    id: typeof e.id === "string" && e.id ? e.id : uuid(),
+    type: e.type,
+    ts: isFiniteNumber(e.ts) ? Math.round(e.ts) : Date.now(),
+    name: truncate(typeof e.name === "string" && e.name ? e.name : "unknown", MAX_NAME)
+  };
+  if (isFiniteNumber(e.status) && e.status >= 100 && e.status <= 599) out.status = Math.trunc(e.status);
+  if (typeof e.ok === "boolean") out.ok = e.ok;
+  if (isFiniteNumber(e.durationMs)) out.durationMs = Math.min(864e5, Math.max(0, Math.round(e.durationMs * 10) / 10));
+  if (isFiniteNumber(e.value)) out.value = e.value;
+  if (e.error && typeof e.error.code === "string") {
+    out.error = { code: truncate(e.error.code, MAX_ERROR_CODE) };
+    if (typeof e.error.message === "string" && e.error.message) {
+      out.error.message = truncate(e.error.message, MAX_ERROR_MESSAGE);
+    }
+  }
+  if (typeof e.merchantId === "string" && e.merchantId) out.merchantId = truncate(e.merchantId, 200);
+  if (typeof e.deliveryId === "string" && e.deliveryId) out.deliveryId = truncate(e.deliveryId, 200);
+  const attrs = cleanAttrs(e.attrs);
+  if (attrs) out.attrs = attrs;
+  return out;
+}
+function errorMessage(err) {
+  try {
+    if (err instanceof Error) return truncate(err.message || err.name, MAX_ERROR_MESSAGE);
+    if (typeof err === "string") return truncate(err, MAX_ERROR_MESSAGE);
+  } catch {
+  }
+  return void 0;
+}
+function joinUrl(endpoint, path) {
+  return endpoint.replace(/\/+$/, "") + path;
+}
+var encoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : void 0;
+function byteLength(s) {
+  return encoder ? encoder.encode(s).length : s.length * 3;
+}
+function buildBodies(events, maxEvents) {
+  const sdk = { name: SDK_NAME, version: SDK_VERSION };
+  const envelope = byteLength(JSON.stringify({ sdk, events: [] }));
+  const out = [];
+  let cur = [];
+  let size = envelope;
+  const push = () => {
+    if (cur.length) out.push({ body: JSON.stringify({ sdk, events: cur }), events: cur });
+    cur = [];
+    size = envelope;
+  };
+  for (const ev of events) {
+    const len = byteLength(JSON.stringify(ev)) + 1;
+    if (cur.length && (cur.length >= maxEvents || size + len > MAX_BATCH_BYTES)) push();
+    cur.push(ev);
+    size += len;
+  }
+  push();
+  return out;
+}
+
+// src/transport.ts
+function unref(t) {
+  t.unref?.();
+  return t;
+}
+var sleep = (ms) => new Promise((r) => unref(setTimeout(r, ms)));
+var Transport = class {
+  constructor(o) {
+    this.o = o;
+  }
+  o;
+  queue = [];
+  timer;
+  immediate;
+  chain = Promise.resolve();
+  warned401 = false;
+  dropped = 0;
+  sent = 0;
+  get size() {
+    return this.queue.length;
+  }
+  enqueue(ev) {
+    this.queue.push(ev);
+    if (this.queue.length > this.o.maxQueueSize) {
+      const over = this.queue.length - this.o.maxQueueSize;
+      this.queue.splice(0, over);
+      this.dropped += over;
+      this.o.log(`queue full, dropped ${over} oldest event(s) (total dropped: ${this.dropped})`);
+    }
+    if (this.queue.length >= this.o.maxBatchSize) this.scheduleSoon();
+    else this.arm();
+  }
+  /** Arms the interval flush if not armed. */
+  arm() {
+    if (this.timer) return;
+    this.timer = unref(
+      setTimeout(() => {
+        this.timer = void 0;
+        void this.flush();
+      }, this.o.flushIntervalMs)
+    );
+  }
+  /** Coalesced flush on the next macrotask (does not block the caller). */
+  scheduleSoon() {
+    if (this.immediate) return;
+    this.immediate = unref(
+      setTimeout(() => {
+        this.immediate = void 0;
+        void this.flush();
+      }, 0)
+    );
+  }
+  /**
+   * Sends everything queued at call time. Calls are serialized, so awaiting
+   * flush() always covers events enqueued before it. Always resolves.
+   */
+  flush() {
+    this.chain = this.chain.then(() => this.drain()).catch((e) => this.o.log("flush failed", e));
+    return this.chain;
+  }
+  async drain() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    if (!this.queue.length) return;
+    const events = this.queue.splice(0, this.queue.length);
+    await this.sendAll(events);
+  }
+  async sendAll(events) {
+    for (const { body, events: evs } of buildBodies(events, this.o.maxBatchSize)) {
+      const ok = await this.send(body);
+      if (ok) this.sent += evs.length;
+      else {
+        this.dropped += evs.length;
+        this.o.log(`dropped batch of ${evs.length} event(s) (total dropped: ${this.dropped})`);
+      }
+    }
+  }
+  async send(body) {
+    const f = this.o.getFetch();
+    if (!f) {
+      this.o.log("no fetch available; cannot send");
+      return false;
+    }
+    const url = joinUrl(this.o.endpoint, "/api/ingest");
+    for (let attempt = 1; attempt <= this.o.maxAttempts; attempt++) {
+      let retryAfterMs;
+      try {
+        const res = await f(url, {
+          method: "POST",
+          headers: { authorization: `Bearer ${this.o.key}`, "content-type": "application/json" },
+          body
+        });
+        res.text().catch(() => void 0);
+        if (res.status >= 200 && res.status < 300) {
+          this.o.log(`sent batch (${res.status})`);
+          return true;
+        }
+        if (res.status === 401 && !this.warned401) {
+          this.warned401 = true;
+          this.o.warn("[kanca] ingest rejected the key (401). Check KANCA_KEY \u2014 events are being dropped.");
+        }
+        if (res.status !== 429 && res.status < 500) {
+          this.o.log(`ingest responded ${res.status}; not retrying`);
+          return false;
+        }
+        const ra = Number(res.headers.get("retry-after"));
+        if (res.status === 429 && Number.isFinite(ra) && ra >= 0) retryAfterMs = Math.min(ra * 1e3, 3e4);
+        this.o.log(`ingest responded ${res.status} (attempt ${attempt}/${this.o.maxAttempts})`);
+      } catch (err) {
+        this.o.log(`network error (attempt ${attempt}/${this.o.maxAttempts})`, err);
+      }
+      if (attempt < this.o.maxAttempts) {
+        const backoff = this.o.retryBaseMs * 2 ** (attempt - 1);
+        const jitter = backoff * 0.2 * Math.random();
+        await sleep(retryAfterMs ?? backoff + jitter);
+      }
+    }
+    return false;
+  }
+};
+
+// src/index.ts
+var exitFlushers = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+function registerExitFlush(fn) {
+  exitFlushers.add(fn);
+  if (exitHookInstalled) return;
+  try {
+    const proc = globalThis.process;
+    if (proc && typeof proc.on === "function") {
+      proc.on("beforeExit", () => {
+        for (const f of [...exitFlushers]) void f();
+      });
+      exitHookInstalled = true;
+    }
+  } catch {
+  }
+}
+var UNINSTALL_SCOPES = [
+  "store/app/deleted",
+  "store/app/uninstalled",
+  "store/authorizedApp/deleted"
+];
+var MARK = /* @__PURE__ */ Symbol.for("kanca.instrumented");
+var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+function clampInt(v, def, min, max) {
+  const n = typeof v === "number" && Number.isFinite(v) ? Math.floor(v) : def;
+  return Math.min(max, Math.max(min, n));
+}
+function isRequest(v) {
+  return typeof Request !== "undefined" && v instanceof Request;
+}
+function toUrl(input) {
+  try {
+    if (typeof input === "string") return new URL(input);
+    if (input instanceof URL) return input;
+    if (input && typeof input.url === "string") return new URL(input.url);
+  } catch {
+  }
+  return void 0;
+}
+function bodyToString(body) {
+  if (typeof body === "string") return body;
+  try {
+    if (body instanceof Uint8Array) return new TextDecoder().decode(body);
+    if (body instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(body));
+  } catch {
+  }
+  return void 0;
+}
+function parseWebhookMeta(text) {
+  try {
+    const j = JSON.parse(text);
+    if (!j || typeof j !== "object" || Array.isArray(j)) return null;
+    const o = j;
+    return {
+      scope: typeof o.scope === "string" && o.scope ? o.scope : void 0,
+      id: typeof o.id === "string" && o.id ? o.id : void 0,
+      merchantId: typeof o.merchantId === "string" && o.merchantId ? o.merchantId : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function noopKanca() {
+  return {
+    webhook: (handler) => async (req, ...rest) => handler(req, ...rest),
+    fetch: ((input, init) => globalThis.fetch(input, init)),
+    instrument: (client) => client,
+    track: () => void 0,
+    flush: () => Promise.resolve(),
+    enabled: false
+  };
+}
+function createKanca(options = {}) {
+  const debug = !!options.debug;
+  const log = (msg, ...args) => {
+    if (debug) console.debug(`[kanca] ${msg}`, ...args);
+  };
+  const warn = (msg) => console.warn(msg);
+  if (options.disabled) {
+    log("disabled; SDK is a no-op");
+    return noopKanca();
+  }
+  const key = typeof options.key === "string" ? options.key.trim() : "";
+  if (!key) {
+    log("no key (KANCA_KEY) configured; SDK is a no-op");
+    return noopKanca();
+  }
+  if (!key.startsWith("kk_")) {
+    warn(
+      key.startsWith("kp_") ? "[kanca] createKanca() needs a server key (kk_...), got a public key (kp_...). Public keys are for reportVitals()/<KancaVitals/> only. SDK disabled." : "[kanca] KANCA_KEY must start with kk_. SDK disabled."
+    );
+    return noopKanca();
+  }
+  const maxBatchSize = clampInt(options.maxBatchSize, 100, 1, MAX_EVENTS_PER_BATCH);
+  const transport = new Transport({
+    key,
+    endpoint: options.endpoint || DEFAULT_ENDPOINT,
+    flushIntervalMs: clampInt(options.flushIntervalMs, 2e3, 0, 60 * 60 * 1e3),
+    maxBatchSize,
+    maxQueueSize: clampInt(options.maxQueueSize, 5e3, maxBatchSize, 1e6),
+    maxAttempts: 3,
+    retryBaseMs: clampInt(options.retryBaseMs, 500, 0, 6e4),
+    log,
+    warn,
+    getFetch: () => typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0
+  });
+  const pending = /* @__PURE__ */ new Set();
+  const observe = (p) => {
+    const tracked = p.catch((e) => log("observation failed", e)).finally(() => pending.delete(tracked));
+    pending.add(tracked);
+  };
+  let keepAlive = false;
+  const holdUntilSent = () => {
+    if (!options.waitUntil || keepAlive) return;
+    keepAlive = true;
+    try {
+      options.waitUntil(
+        new Promise((r) => setTimeout(r, 0)).then(flush).finally(() => {
+          keepAlive = false;
+        })
+      );
+    } catch (e) {
+      keepAlive = false;
+      log("waitUntil threw", e);
+    }
+  };
+  const emit = (ev) => {
+    try {
+      const clean = sanitizeEvent({ ...ev, id: ev.id ?? uuid() });
+      transport.enqueue(clean);
+      registerExitFlush(flush);
+      holdUntilSent();
+      log(`${clean.type} ${clean.name}`, { status: clean.status, ok: clean.ok, durationMs: clean.durationMs });
+    } catch (e) {
+      log("failed to record event", e);
+    }
+  };
+  const flush = async () => {
+    try {
+      while (pending.size) await Promise.allSettled([...pending]);
+      await transport.flush();
+    } catch (e) {
+      log("flush error", e);
+    }
+    if (!transport.size && !pending.size) exitFlushers.delete(flush);
+  };
+  const afterDelivery = () => {
+    transport.scheduleSoon();
+    if (options.waitUntil) {
+      try {
+        options.waitUntil(flush());
+      } catch (e) {
+        log("waitUntil threw", e);
+      }
+    }
+  };
+  const webhook = (handler) => async function kancaWebhook(req, ...rest) {
+    const ts = Date.now();
+    const t0 = now();
+    let meta;
+    try {
+      meta = req.clone().text().then(parseWebhookMeta, () => null);
+    } catch {
+      meta = Promise.resolve(null);
+    }
+    const record = (status, error, durationMs) => {
+      observe(
+        meta.then((m) => {
+          const base = { ts, merchantId: m?.merchantId, deliveryId: m?.id };
+          emit({
+            ...base,
+            type: "webhook",
+            name: m?.scope ?? "unknown",
+            status,
+            ok: status === 200,
+            durationMs,
+            error
+          });
+          if (m?.scope && UNINSTALL_SCOPES.includes(m.scope)) emit({ ...base, type: "uninstall", name: "uninstall" });
+        })
+      );
+      afterDelivery();
+    };
+    let res;
+    try {
+      res = await handler.call(this, req, ...rest);
+    } catch (err) {
+      try {
+        record(500, { code: "HANDLER_THREW", message: errorMessage(err) }, now() - t0);
+      } catch {
+      }
+      throw err;
+    }
+    try {
+      const status = res && typeof res.status === "number" ? res.status : void 0;
+      record(status, status === void 0 ? { code: "NO_RESPONSE", message: "handler did not return a Response" } : status === 200 ? void 0 : { code: `HTTP_${status}` }, now() - t0);
+    } catch {
+    }
+    return res;
+  };
+  const kfetch = async function kancaFetch(input, init) {
+    const base = globalThis.fetch;
+    let url;
+    let method = "GET";
+    let gql = false;
+    let opName;
+    try {
+      url = toUrl(input);
+      method = (init?.method ?? (isRequest(input) ? input.method : "GET")).toUpperCase();
+      gql = !!url && isIkasGraphqlUrl(url);
+      if (gql) {
+        if (init && init.body != null) opName = Promise.resolve(operationNameFromBody(bodyToString(init.body)));
+        else if (isRequest(input) && input.body) opName = input.clone().text().then(operationNameFromBody, () => "anonymous");
+        else opName = Promise.resolve("anonymous");
+      }
+    } catch {
+      url = void 0;
+    }
+    if (!url) return base(input, init);
+    const ts = Date.now();
+    const t0 = now();
+    let res;
+    try {
+      res = await base(input, init);
+    } catch (err) {
+      const durationMs2 = now() - t0;
+      try {
+        const error = { code: "NETWORK", message: errorMessage(err) };
+        if (gql) observe((opName ?? Promise.resolve("anonymous")).then((name) => emit({ type: "graphql", name, ts, ok: false, durationMs: durationMs2, error })));
+        else emit({ type: "rest", name: `${method} ${url.host}${url.pathname}`, ts, ok: false, durationMs: durationMs2, error });
+      } catch {
+      }
+      throw err;
+    }
+    const durationMs = now() - t0;
+    try {
+      const status = res.status;
+      if (gql) {
+        let clone;
+        try {
+          clone = res.clone();
+        } catch {
+          clone = void 0;
+        }
+        observe(
+          (async () => {
+            const name = await (opName ?? Promise.resolve("anonymous"));
+            let json;
+            try {
+              json = clone ? JSON.parse(await clone.text()) : void 0;
+            } catch {
+              json = void 0;
+            }
+            const out = classifyGraphql(status, json);
+            emit({
+              type: "graphql",
+              name,
+              ts,
+              status,
+              ok: out.ok,
+              durationMs,
+              error: out.ok ? void 0 : { code: out.code ?? `HTTP_${status}`, message: out.message }
+            });
+          })()
+        );
+      } else {
+        const ok = status < 400;
+        emit({ type: "rest", name: `${method} ${url.host}${url.pathname}`, ts, status, ok, durationMs, error: ok ? void 0 : { code: `HTTP_${status}` } });
+      }
+    } catch {
+    }
+    return res;
+  };
+  let warnedInstrument = false;
+  const instrument = (client, opts) => {
+    const c = client;
+    try {
+      if (!c || typeof c !== "object" || typeof c.createGraphQLClient !== "function" || !c._client || typeof c._client.request !== "function") {
+        if (!warnedInstrument) {
+          warnedInstrument = true;
+          warn(
+            "[kanca] instrument(): not an @ikas/admin-api-client client (expected createGraphQLClient() and _client.request()). Nothing will be recorded for it \u2014 use kanca.fetch instead."
+          );
+        }
+        return client;
+      }
+      if (c[MARK]) return client;
+      const merchantIdFor = () => {
+        if (opts?.merchantId) return opts.merchantId;
+        const m = c.tokenData?.merchantId;
+        return typeof m === "string" && m ? m : void 0;
+      };
+      const wrap = (gc) => {
+        const g = gc;
+        if (!g || typeof g.request !== "function" || g[MARK]) return gc;
+        const orig = g.request;
+        g.request = async function(...args) {
+          let name = "anonymous";
+          try {
+            const a0 = args[0];
+            const doc = typeof a0 === "string" ? a0 : a0 && typeof a0 === "object" && "document" in a0 ? a0.document : a0;
+            const text = typeof doc === "string" ? doc : doc?.loc?.source?.body;
+            name = operationName(text, typeof a0 === "object" ? a0?.operationName : void 0);
+          } catch {
+          }
+          const ts = Date.now();
+          const t0 = now();
+          try {
+            const data = await orig.apply(this, args);
+            emit({ type: "graphql", name, ts, ok: true, durationMs: now() - t0, merchantId: merchantIdFor() });
+            return data;
+          } catch (err) {
+            try {
+              const durationMs = now() - t0;
+              const resp = err?.response;
+              if (resp && typeof resp.status === "number") {
+                const out = classifyGraphql(resp.status, { errors: Array.isArray(resp.errors) ? resp.errors : [] });
+                emit({
+                  type: "graphql",
+                  name,
+                  ts,
+                  status: resp.status,
+                  ok: false,
+                  durationMs,
+                  merchantId: merchantIdFor(),
+                  error: { code: out.code ?? `HTTP_${resp.status}`, message: out.message }
+                });
+              } else {
+                emit({ type: "graphql", name, ts, ok: false, durationMs, merchantId: merchantIdFor(), error: { code: "NETWORK", message: errorMessage(err) } });
+              }
+            } catch {
+            }
+            throw err;
+          }
+        };
+        g[MARK] = true;
+        return gc;
+      };
+      const origCreate = c.createGraphQLClient;
+      c.createGraphQLClient = function(...a) {
+        return wrap(origCreate.apply(this, a));
+      };
+      c._client = wrap(c._client);
+      c[MARK] = true;
+      log("instrumented @ikas/admin-api-client");
+    } catch (e) {
+      log("instrument failed", e);
+    }
+    return client;
+  };
+  const track = (type, fields = {}) => {
+    try {
+      const f = fields ?? {};
+      let name = f.name;
+      if (type === "install" || type === "uninstall") name = type;
+      let ok = f.ok;
+      if (ok === void 0 && typeof f.status === "number") {
+        if (type === "webhook") ok = f.status === 200;
+        else if (type === "graphql") ok = f.status >= 200 && f.status < 300;
+        else if (type === "rest") ok = f.status < 400;
+      }
+      const attrs = { ...f.attrs ?? {} };
+      if (typeof f.storeName === "string" && f.storeName) attrs.storeName = f.storeName;
+      emit({
+        type,
+        name: name ?? "unknown",
+        ts: f.ts ?? Date.now(),
+        status: f.status,
+        ok,
+        durationMs: f.durationMs,
+        value: f.value,
+        error: f.error,
+        merchantId: f.merchantId,
+        deliveryId: f.deliveryId,
+        attrs
+      });
+      if (type === "install") transport.scheduleSoon();
+    } catch (e) {
+      log("track failed", e);
+    }
+  };
+  log(`enabled \u2192 ${options.endpoint || DEFAULT_ENDPOINT}`);
+  return {
+    webhook,
+    fetch: kfetch,
+    instrument,
+    track,
+    flush,
+    enabled: true
+  };
+}
+//# sourceMappingURL=index.cjs.map