@kywi-software/js 0.1.0

package/dist/kywi.js

@@ -0,0 +1,1339 @@
+"use strict";
+var Kywi = (() => {
+  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, {
+    Kywi: () => Kywi,
+    bootAudienceEngine: () => bootAudienceEngine,
+    bootExperiments: () => bootExperiments
+  });
+
+  // src/context.ts
+  function readContext() {
+    const meta = (name) => {
+      if (typeof document === "undefined") return "";
+      const el = document.querySelector(`meta[name="kywi:${name}"]`);
+      return el?.getAttribute("content") ?? "";
+    };
+    return {
+      siteId: meta("site-id") || document?.documentElement?.getAttribute("data-kywi-site") || "",
+      locale: document?.documentElement?.lang || "en",
+      themePath: meta("theme-path") || "",
+      basePath: meta("base-path") || "/",
+      csrfToken: meta("csrf-token") || "",
+      isEditMode: document?.body?.classList?.contains("kywi-edit-mode") ?? false
+    };
+  }
+
+  // src/entity.ts
+  function createEntity(type, basePath, csrfToken, data) {
+    const fields = { ...data };
+    const dirty = /* @__PURE__ */ new Map();
+    const errors = [];
+    const headers = { "Content-Type": "application/json" };
+    if (csrfToken) headers["X-CSRF-Token"] = csrfToken;
+    const entity = {
+      get(field) {
+        return fields[field];
+      },
+      set(field, value) {
+        fields[field] = value;
+        dirty.set(field, value);
+        return entity;
+      },
+      async save() {
+        const id = fields["id"];
+        const url = id ? `${basePath}/content/${type}/${id}` : `${basePath}/content/${type}`;
+        const res = await fetch(url, { method: id ? "PUT" : "POST", headers, body: JSON.stringify(Object.fromEntries(dirty)) });
+        const json = await res.json();
+        if (!res.ok || json.error) {
+          errors.push(json.error?.message ?? "Save failed");
+          throw entity;
+        }
+        if (json.data) Object.assign(fields, json.data);
+        dirty.clear();
+        return entity;
+      },
+      async delete() {
+        const id = fields["id"];
+        await fetch(`${basePath}/content/${type}/${id}`, { method: "DELETE", headers });
+      },
+      getErrors() {
+        return [...errors];
+      },
+      async loadBy(field, value) {
+        const url = field === "id" ? `${basePath}/content/${type}/${value}` : `${basePath}/content/${type}?${field}=${encodeURIComponent(value)}`;
+        const res = await fetch(url, { headers });
+        const json = await res.json();
+        if (!res.ok || json.error) {
+          errors.push(json.error?.message ?? "Load failed");
+          throw entity;
+        }
+        if (json.data) Object.assign(fields, json.data);
+        return entity;
+      }
+    };
+    return entity;
+  }
+  function createEntityFactory(basePath, csrfToken) {
+    return (type) => createEntity(type, basePath, csrfToken, {});
+  }
+
+  // src/feed.ts
+  var PropBuilder = class {
+    constructor(builder, field, conj) {
+      this.builder = builder;
+      this.field = field;
+      this.conj = conj;
+    }
+    add(op, value) {
+      this.builder._filters.push({ field: this.field, operator: op, value, conjunction: this.conj });
+      return this.builder;
+    }
+    isEQ(v) {
+      return this.add("eq", v);
+    }
+    isNEQ(v) {
+      return this.add("neq", v);
+    }
+    isLT(v) {
+      return this.add("lt", v);
+    }
+    isLTE(v) {
+      return this.add("lte", v);
+    }
+    isGT(v) {
+      return this.add("gt", v);
+    }
+    isGTE(v) {
+      return this.add("gte", v);
+    }
+    beginsWith(v) {
+      return this.add("beginsWith", v);
+    }
+    endsWith(v) {
+      return this.add("endsWith", v);
+    }
+    contains(v) {
+      return this.add("contains", v);
+    }
+    isNull() {
+      return this.add("isNull");
+    }
+    isNotNull() {
+      return this.add("isNotNull");
+    }
+  };
+  var FeedBuilder = class {
+    constructor(contentType, basePath, csrfToken) {
+      this.contentType = contentType;
+      this.basePath = basePath;
+      this.csrfToken = csrfToken;
+    }
+    _filters = [];
+    _sort = null;
+    _limit = null;
+    _page = null;
+    where() {
+      return this;
+    }
+    prop(field) {
+      return new PropBuilder(this, field, "and");
+    }
+    andProp(field) {
+      return new PropBuilder(this, field, "and");
+    }
+    orProp(field) {
+      return new PropBuilder(this, field, "or");
+    }
+    sort(field, direction = "asc") {
+      this._sort = { field, direction };
+      return this;
+    }
+    maxItems(n) {
+      this._limit = n;
+      return this;
+    }
+    page(n) {
+      this._page = n;
+      return this;
+    }
+    buildBody() {
+      const filterArray = this._filters.map((f) => ({
+        field: f.field,
+        operator: f.operator,
+        value: f.value,
+        conjunction: f.conjunction
+      }));
+      const body = { contentType: this.contentType };
+      if (filterArray.length > 0) body["filters"] = filterArray;
+      if (this._sort) body["sort"] = this._sort;
+      if (this._limit !== null) body["limit"] = this._limit;
+      if (this._page !== null) body["page"] = this._page;
+      return body;
+    }
+    buildHeaders() {
+      const headers = { "Content-Type": "application/json" };
+      if (this.csrfToken) headers["X-CSRF-Token"] = this.csrfToken;
+      return headers;
+    }
+    async aggregate(fn, field) {
+      const body = this.buildBody();
+      const agg = { function: fn };
+      if (field) agg["field"] = field;
+      body["aggregate"] = agg;
+      const res = await fetch(`${this.basePath}/feeds/aggregate`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify(body)
+      });
+      const json = await res.json();
+      return json.data ?? {};
+    }
+    async getQuery() {
+      const body = this.buildBody();
+      const res = await fetch(`${this.basePath}/feeds/query`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify(body)
+      });
+      const json = await res.json();
+      const payload = json.data;
+      const rawItems = Array.isArray(payload) ? payload : payload?.items ?? [];
+      const total = Array.isArray(payload) ? json.meta?.total ?? rawItems.length : payload?.total ?? rawItems.length;
+      const page = Array.isArray(payload) ? json.meta?.page ?? 1 : payload?.page ?? 1;
+      const pages = Array.isArray(payload) ? json.meta?.totalPages ?? 0 : payload?.totalPages ?? 0;
+      const items = rawItems.map((d) => ({
+        get(field) {
+          return d[field];
+        },
+        set() {
+          throw new Error("Feed results are read-only");
+        },
+        save() {
+          return Promise.reject(new Error("Feed results are read-only"));
+        },
+        delete() {
+          return Promise.reject(new Error("Feed results are read-only"));
+        },
+        getErrors() {
+          return [];
+        },
+        loadBy() {
+          return Promise.reject(new Error("Use Kywi.getEntity() to load by field"));
+        }
+      }));
+      return { items, total, page, pages };
+    }
+  };
+  function createFeedFactory(basePath, csrfToken) {
+    return (type) => new FeedBuilder(type, basePath, csrfToken);
+  }
+
+  // src/render-feed.ts
+  async function renderFeed(options) {
+    const { feed, container, template, loadingText = "", emptyText = "", wrapperTag = "div", wrapperClass, unsafeHtml = false, onRender } = options;
+    if (loadingText) container.textContent = loadingText;
+    const result = await feed.getQuery();
+    container.textContent = "";
+    if (result.items.length === 0) {
+      if (emptyText) container.textContent = emptyText;
+      return;
+    }
+    const wrapper = document.createElement(wrapperTag);
+    if (wrapperClass) wrapper.className = wrapperClass;
+    for (const item of result.items) {
+      const rendered = template(item);
+      if (rendered instanceof Node) {
+        wrapper.appendChild(rendered);
+      } else if (unsafeHtml) {
+        const span = document.createElement("span");
+        span["innerHTML"] = rendered;
+        wrapper.appendChild(span);
+      } else {
+        const span = document.createElement("span");
+        span.textContent = rendered;
+        wrapper.appendChild(span);
+      }
+    }
+    container.appendChild(wrapper);
+    if (onRender) onRender(container);
+  }
+
+  // src/module-system.ts
+  function readParams(el) {
+    const params = {};
+    for (const attr of Array.from(el.attributes)) {
+      if (attr.name.startsWith("data-kywi-param-")) {
+        params[attr.name.slice(16)] = attr.value;
+      }
+    }
+    return params;
+  }
+  function initModules() {
+    const elements = document.querySelectorAll("[data-kywi-module]");
+    for (const el of Array.from(elements)) {
+      const htmlEl = el;
+      const moduleName = htmlEl.getAttribute("data-kywi-module");
+      if (!moduleName) continue;
+      const def = Kywi.Module[moduleName];
+      if (!def || !def.renderClient) continue;
+      const context = { targetEl: htmlEl, ...readParams(htmlEl) };
+      def.renderClient.call({ context, ...def });
+    }
+  }
+
+  // src/form-hooks.ts
+  function initFormHooks() {
+    const forms = document.querySelectorAll("[data-kywi-form]");
+    for (const formEl of Array.from(forms)) {
+      const htmlForm = formEl;
+      const hooks = Kywi.DisplayObject.Form._hooks;
+      if (hooks["onAfterRender"]) hooks["onAfterRender"].call({ context: { targetEl: htmlForm } });
+      htmlForm.addEventListener("submit", (e) => {
+        if (hooks["onSubmit"]) {
+          const result = hooks["onSubmit"].call({ context: { targetEl: htmlForm } });
+          if (result === false) e.preventDefault();
+        }
+      });
+    }
+  }
+
+  // src/experiments/index.ts
+  function apiBaseFrom(ctx) {
+    return ctx.basePath && ctx.basePath !== "/" ? `${ctx.basePath}/api/v1` : "/api/v1";
+  }
+  function metaContent(name) {
+    if (typeof document === "undefined") return null;
+    return document.querySelector(`meta[name="kywi:${name}"]`)?.getAttribute("content") ?? null;
+  }
+  var submitListenerInstalled = false;
+  var currentFormConversion = null;
+  function installFormListener() {
+    if (submitListenerInstalled || typeof document === "undefined") return;
+    submitListenerInstalled = true;
+    document.addEventListener(
+      "submit",
+      (e) => {
+        const form = e.target;
+        if (!form || form.tagName !== "FORM") return;
+        const formId = form.getAttribute("data-kywi-form-id") ?? form.getAttribute("id");
+        if (formId && currentFormConversion) currentFormConversion(formId);
+      },
+      true
+    );
+  }
+  function beacon(url, body, csrfToken) {
+    try {
+      void fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...csrfToken ? { "X-CSRF-Token": csrfToken } : {} },
+        body: JSON.stringify(body),
+        keepalive: true
+      }).catch(() => {
+      });
+    } catch {
+    }
+  }
+  function bootExperiments(config = {}) {
+    const ctx = config.context ?? readContext();
+    const apiBase = config.apiBase ?? apiBaseFrom(ctx);
+    const csrf = ctx.csrfToken || void 0;
+    const experimentId = metaContent("experiment-id");
+    const visitorId = config.visitorId ?? metaContent("visitor-id") ?? void 0;
+    const currentPath = config.currentPath ?? (typeof location !== "undefined" ? location.pathname : "/");
+    function trackConversion(signal) {
+      beacon(`${apiBase}/kywi/experiments/conversion`, { visitorId, event: signal }, csrf);
+    }
+    function track(eventName) {
+      trackConversion({ type: "custom", eventName });
+    }
+    if (experimentId) {
+      beacon(`${apiBase}/kywi/experiments/exposure`, { experimentId, visitorId }, csrf);
+    }
+    if (config.autoPageview !== false) {
+      trackConversion({ type: "pageview", url: currentPath });
+    }
+    currentFormConversion = (formId) => trackConversion({ type: "form_submit", formId });
+    installFormListener();
+    const runtime = { track, trackConversion };
+    const g = globalThis.kywi ?? {};
+    g["track"] = track;
+    g["trackConversion"] = trackConversion;
+    globalThis.kywi = g;
+    return runtime;
+  }
+
+  // ../core/dist/audiences/types.js
+  function createEmptySignals() {
+    return {
+      utm: { source: null, medium: null, campaign: null, term: null, content: null },
+      referrer: { raw: null, domain: null, sourceType: "direct" },
+      session: { pageViewCount: 0, totalPageViews: 0, sessionDuration: 0, entryPage: "/", pagesVisited: [] },
+      behavioral: { categoryScores: {}, totalScore: 0 },
+      selfId: {},
+      identity: { visitorId: "", isKnown: false, maLeadId: null },
+      adapters: {},
+      meta: { isOptedOut: false, isPreview: false, previewAudienceId: null, resolvedAt: "server" }
+    };
+  }
+
+  // ../core/dist/audiences/evaluator/glob.js
+  function matchGlob(pattern, value) {
+    const parts = pattern.split("*");
+    if (parts.length === 1)
+      return pattern === value;
+    let pos = 0;
+    const first = parts[0];
+    if (first !== "") {
+      if (!value.startsWith(first))
+        return false;
+      pos = first.length;
+    }
+    for (let i = 1; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (part === "")
+        continue;
+      const idx = value.indexOf(part, pos);
+      if (idx < 0)
+        return false;
+      pos = idx + part.length;
+    }
+    const last = parts[parts.length - 1];
+    if (last !== "") {
+      if (!value.endsWith(last))
+        return false;
+      if (value.length - last.length < pos)
+        return false;
+    }
+    return true;
+  }
+
+  // ../core/dist/audiences/evaluator/instant-match.js
+  function resolveSignalValue(signals, ref) {
+    if (ref === "utm.source")
+      return signals.utm.source;
+    if (ref === "utm.medium")
+      return signals.utm.medium;
+    if (ref === "utm.campaign")
+      return signals.utm.campaign;
+    if (ref === "utm.term")
+      return signals.utm.term;
+    if (ref === "utm.content")
+      return signals.utm.content;
+    if (ref === "referrer.domain")
+      return signals.referrer.domain;
+    if (ref === "referrer.sourceType")
+      return signals.referrer.sourceType;
+    if (ref === "identity.isKnown")
+      return signals.identity.isKnown ? "true" : "false";
+    if (ref === "session.entryPage")
+      return signals.session.entryPage;
+    if (ref === "session.pagesVisited")
+      return signals.session.pagesVisited.join(",");
+    if (ref.startsWith("selfId.")) {
+      const key = ref.slice(7);
+      return signals.selfId[key] ?? null;
+    }
+    if (ref.startsWith("adapter.")) {
+      const key = ref.slice(8);
+      const val = signals.adapters[key];
+      return val !== void 0 && val !== null ? String(val) : null;
+    }
+    return null;
+  }
+  function evaluateInstantCondition(condition, signals) {
+    const actual = resolveSignalValue(signals, condition.signal);
+    const expected = condition.value;
+    switch (condition.operator) {
+      case "equals":
+        return actual === expected;
+      case "not_equals":
+        return actual !== expected;
+      case "contains":
+        return actual !== null && typeof expected === "string" && actual.includes(expected);
+      case "starts_with":
+        return actual !== null && typeof expected === "string" && actual.startsWith(expected);
+      case "matches_glob":
+        return actual !== null && typeof expected === "string" && matchGlob(expected, actual);
+      case "is_one_of":
+        return actual !== null && Array.isArray(condition.value) && condition.value.includes(actual);
+      case "is_true":
+        return actual === "true";
+      case "is_false":
+        return actual === "false";
+      case "gte":
+        return actual !== null && typeof expected === "string" && Number(actual) >= Number(expected);
+      case "lte":
+        return actual !== null && typeof expected === "string" && Number(actual) <= Number(expected);
+      default:
+        return false;
+    }
+  }
+
+  // ../core/dist/audiences/evaluator/score.js
+  function evaluateOneScore(cond, signals) {
+    const threshold = cond.threshold ?? 0;
+    switch (cond.trigger) {
+      case "pageViewCount":
+        return signals.session.pageViewCount >= threshold ? cond.points : 0;
+      case "totalPageViews":
+        return signals.session.totalPageViews >= threshold ? cond.points : 0;
+      case "timeOnSite":
+        return signals.session.sessionDuration >= threshold ? cond.points : 0;
+      case "categoryViewed": {
+        const cat = cond.category ?? "";
+        const score = signals.behavioral.categoryScores[cat];
+        return score !== void 0 && score >= threshold ? cond.points : 0;
+      }
+      case "urlMatch": {
+        const pattern = cond.pattern ?? "*";
+        const matched = signals.session.pagesVisited.some((url) => matchGlob(pattern, url));
+        return matched ? cond.points : 0;
+      }
+      case "signalMatch": {
+        if (!cond.signal || !cond.operator)
+          return 0;
+        const matched = evaluateInstantCondition({
+          type: "instant",
+          id: cond.id,
+          groupId: cond.groupId,
+          signal: cond.signal,
+          operator: cond.operator,
+          value: cond.value ?? ""
+        }, signals);
+        return matched ? cond.points : 0;
+      }
+      default:
+        return 0;
+    }
+  }
+  function evaluateScoreConditions(conditions, signals) {
+    let total = 0;
+    for (const cond of conditions) {
+      total += evaluateOneScore(cond, signals);
+    }
+    return total;
+  }
+
+  // ../core/dist/audiences/evaluator/condition-registry.js
+  var registry = /* @__PURE__ */ new Map();
+  function evaluateCustomCondition(condition, signals) {
+    const evaluator = registry.get(condition.type);
+    if (!evaluator)
+      return false;
+    return evaluator(condition, signals);
+  }
+  function hasConditionType(name) {
+    return registry.has(name);
+  }
+
+  // ../core/dist/audiences/evaluator/resolver.js
+  function evaluateGroup(group, signals) {
+    const conditionTraces = [];
+    const instants = [];
+    const scores = [];
+    const customs = [];
+    for (const c of group.conditions) {
+      const conditionType = c.type;
+      if (c.type === "instant")
+        instants.push(c);
+      else if (c.type === "score")
+        scores.push(c);
+      else if (hasConditionType(conditionType))
+        customs.push(c);
+    }
+    let allInstantsPassed = true;
+    for (const ic of instants) {
+      const passed = evaluateInstantCondition(ic, signals);
+      conditionTraces.push({ conditionId: ic.id, type: "instant", passed });
+      if (!passed)
+        allInstantsPassed = false;
+    }
+    for (const cc of customs) {
+      const passed = evaluateCustomCondition(cc, signals);
+      conditionTraces.push({ conditionId: cc.id, type: cc.type, passed });
+      if (!passed)
+        allInstantsPassed = false;
+    }
+    const totalScore = evaluateScoreConditions(scores, signals);
+    for (const sc of scores) {
+      const contributed = evaluateScoreConditions([sc], signals);
+      conditionTraces.push({ conditionId: sc.id, type: "score", passed: contributed > 0, scoreContributed: contributed });
+    }
+    return { matched: allInstantsPassed, conditionTraces, totalScore };
+  }
+  function resolveAudiences(audiences, signals) {
+    const allMatchedIds = [];
+    const traces = [];
+    for (const audience of audiences) {
+      const groupTraces = [];
+      let audienceMatched = false;
+      let accumulatedScore = 0;
+      for (const group of audience.conditionGroups) {
+        const { matched, conditionTraces, totalScore } = evaluateGroup(group, signals);
+        accumulatedScore += totalScore;
+        groupTraces.push({ groupId: group.id, matched, conditionTraces });
+        if (matched)
+          audienceMatched = true;
+      }
+      if (audience.scoreThreshold !== null) {
+        const scoreThresholdMet = accumulatedScore >= audience.scoreThreshold;
+        const hasInstantConditions = audience.conditionGroups.some((g) => g.conditions.some((c) => c.type === "instant"));
+        if (hasInstantConditions) {
+          audienceMatched = audienceMatched && scoreThresholdMet;
+        } else {
+          audienceMatched = scoreThresholdMet;
+        }
+      }
+      traces.push({
+        audienceId: audience.id,
+        matched: audienceMatched,
+        groupTraces,
+        ...accumulatedScore > 0 ? { totalScore: accumulatedScore } : {}
+      });
+      if (audienceMatched)
+        allMatchedIds.push(audience.id);
+    }
+    return { winningAudienceId: allMatchedIds[0] ?? null, allMatchedIds, traces };
+  }
+
+  // src/audience/behavioral-collector.ts
+  var SESSION_KEY = "kywi_session";
+  var TOTAL_VIEWS_KEY = "kywi_total_views";
+  var CATEGORY_SCORES_KEY = "kywi_category_scores";
+  var SESSION_START_KEY = "kywi_session_start";
+  function getSession() {
+    const raw = sessionStorage.getItem(SESSION_KEY);
+    if (raw) {
+      try {
+        return JSON.parse(raw);
+      } catch {
+      }
+    }
+    return { pageViewCount: 0, entryPage: "", pagesVisited: [] };
+  }
+  function getSessionStart() {
+    const raw = sessionStorage.getItem(SESSION_START_KEY);
+    if (raw) return Number(raw);
+    const now = Date.now();
+    sessionStorage.setItem(SESSION_START_KEY, String(now));
+    return now;
+  }
+  function getCategoryScores() {
+    const raw = localStorage.getItem(CATEGORY_SCORES_KEY);
+    if (raw) {
+      try {
+        return JSON.parse(raw);
+      } catch {
+      }
+    }
+    return {};
+  }
+  function collectBehavioral(currentPath, category) {
+    const session = getSession();
+    session.pageViewCount += 1;
+    if (!session.entryPage) session.entryPage = currentPath;
+    session.pagesVisited.push(currentPath);
+    sessionStorage.setItem(SESSION_KEY, JSON.stringify(session));
+    const totalViews = (Number(localStorage.getItem(TOTAL_VIEWS_KEY)) || 0) + 1;
+    localStorage.setItem(TOTAL_VIEWS_KEY, String(totalViews));
+    const sessionStart = getSessionStart();
+    const categoryScores = getCategoryScores();
+    if (category) {
+      categoryScores[category] = (categoryScores[category] ?? 0) + 1;
+      localStorage.setItem(CATEGORY_SCORES_KEY, JSON.stringify(categoryScores));
+    }
+    return {
+      session: { pageViewCount: session.pageViewCount, totalPageViews: totalViews, sessionDuration: Math.floor((Date.now() - sessionStart) / 1e3), entryPage: session.entryPage, pagesVisited: session.pagesVisited },
+      behavioral: { categoryScores, totalScore: 0 }
+    };
+  }
+
+  // src/audience/selfid-collector.ts
+  var SELFID_KEY = "kywi_selfid";
+  function collectSelfId() {
+    const raw = localStorage.getItem(SELFID_KEY);
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  function storeSelfId(responses) {
+    localStorage.setItem(SELFID_KEY, JSON.stringify(responses));
+  }
+
+  // src/audience/evaluate.ts
+  function merge(base, partial) {
+    return {
+      utm: partial.utm ?? base.utm,
+      referrer: partial.referrer ?? base.referrer,
+      session: partial.session ?? base.session,
+      behavioral: partial.behavioral ?? base.behavioral,
+      selfId: { ...base.selfId, ...partial.selfId },
+      identity: partial.identity ?? base.identity,
+      adapters: { ...base.adapters, ...partial.adapters },
+      meta: { ...base.meta, ...partial.meta }
+    };
+  }
+  function evaluateClientSide(audiences, serverSignals, currentPath, pageCategory) {
+    let signals = merge(createEmptySignals(), serverSignals);
+    const client = collectBehavioral(currentPath, pageCategory);
+    const selfId = collectSelfId();
+    signals = merge(signals, { session: client.session, behavioral: client.behavioral, selfId, meta: { ...signals.meta, resolvedAt: "client" } });
+    const { winningAudienceId, allMatchedIds } = resolveAudiences(audiences, signals);
+    const isOptedOut2 = signals.meta.isOptedOut;
+    return { winningAudienceId: isOptedOut2 ? null : winningAudienceId, allMatchedIds, signals, isOptedOut: isOptedOut2 };
+  }
+
+  // src/audience/dom-patcher.ts
+  function patchVariantContainers(winningAudienceId) {
+    const containers = document.querySelectorAll(".kywi-variant-container");
+    for (const container of Array.from(containers)) {
+      const el = container;
+      el.classList.remove("kywi-variant-loading");
+      el.removeAttribute("aria-busy");
+      const skeleton = el.querySelector(".kywi-variant-skeleton");
+      if (skeleton) skeleton.remove();
+      const target = winningAudienceId ?? "default";
+      el.setAttribute("data-variant", target);
+      for (const child of Array.from(el.querySelectorAll("[data-kywi-variant]"))) {
+        const h = child;
+        h.style.display = h.getAttribute("data-kywi-variant") === target ? "" : "none";
+      }
+    }
+  }
+
+  // src/cookies.ts
+  var COOKIE_NAMES = {
+    SIGNALS: "kywi_signals",
+    VISITOR: "kywi_visitor",
+    UTM: "kywi_utm",
+    AUDIENCE: "kywi_audience",
+    OPTOUT: "kywi_optout",
+    KNOWN: "kywi_known",
+    PREVIEW_INIT: "kywi_preview_init"
+  };
+  function readCookies() {
+    const map = /* @__PURE__ */ new Map();
+    if (typeof document === "undefined") return map;
+    for (const pair of document.cookie.split(";")) {
+      const trimmed = pair.trim();
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx < 0) continue;
+      map.set(trimmed.slice(0, eqIdx), decodeURIComponent(trimmed.slice(eqIdx + 1)));
+    }
+    return map;
+  }
+  function setCookie(name, value, maxAge) {
+    let str = `${name}=${encodeURIComponent(value)}; Path=/; SameSite=Lax`;
+    if (maxAge !== void 0 && maxAge >= 0) str += `; Max-Age=${maxAge}`;
+    document.cookie = str;
+  }
+  function deleteCookie(name) {
+    document.cookie = `${name}=; Path=/; Max-Age=0`;
+  }
+
+  // src/audience/transparency-styles.ts
+  var STYLE_ELEMENT_ID = "kywi-transparency-styles";
+  var CSS = `
+.kywi-transparency-bar,
+.kywi-transparency-bar * {
+  box-sizing: border-box;
+}
+.kywi-transparency-bar {
+  position: fixed;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 2147483000;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 12px;
+  margin: 0;
+  padding: 12px 16px;
+  background: rgba(23, 23, 28, 0.96);
+  color: #f4f4f5;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+  font-size: 13px;
+  line-height: 1.4;
+  border-top: 1px solid rgba(255, 255, 255, 0.12);
+  box-shadow: 0 -2px 12px rgba(0, 0, 0, 0.25);
+  animation: kywi-transparency-in 220ms ease-out;
+}
+@media (prefers-reduced-motion: reduce) {
+  .kywi-transparency-bar { animation: none; }
+}
+@keyframes kywi-transparency-in {
+  from { transform: translateY(100%); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+.kywi-transparency-text {
+  flex: 1 1 240px;
+  color: #f4f4f5;
+}
+.kywi-transparency-bar button {
+  appearance: none;
+  -webkit-appearance: none;
+  font-family: inherit;
+  font-size: 12px;
+  line-height: 1.4;
+  cursor: pointer;
+  border-radius: 999px;
+  transition: background 120ms ease, border-color 120ms ease, color 120ms ease;
+}
+.kywi-transparency-opt-out,
+.kywi-transparency-opt-in {
+  flex: 0 0 auto;
+  padding: 6px 14px;
+  border: 1px solid rgba(255, 255, 255, 0.35);
+  background: transparent;
+  color: #f4f4f5;
+  font-weight: 600;
+}
+.kywi-transparency-opt-out:hover,
+.kywi-transparency-opt-in:hover {
+  background: rgba(255, 255, 255, 0.12);
+  border-color: rgba(255, 255, 255, 0.5);
+}
+.kywi-transparency-dismiss {
+  flex: 0 0 auto;
+  width: 26px;
+  height: 26px;
+  padding: 0;
+  border: 1px solid transparent;
+  background: transparent;
+  color: #d4d4d8;
+  font-size: 13px;
+}
+.kywi-transparency-dismiss:hover {
+  background: rgba(255, 255, 255, 0.1);
+  color: #f4f4f5;
+}
+.kywi-transparency-bar button:focus-visible {
+  outline: 2px solid #7dd3fc;
+  outline-offset: 2px;
+}
+@media (max-width: 480px) {
+  .kywi-transparency-bar {
+    padding: 10px 12px;
+  }
+  .kywi-transparency-text {
+    flex-basis: 100%;
+  }
+}
+`;
+  function ensureTransparencyStyles() {
+    if (typeof document === "undefined") return;
+    if (document.getElementById(STYLE_ELEMENT_ID)) return;
+    const style = document.createElement("style");
+    style.id = STYLE_ELEMENT_ID;
+    style.textContent = CSS;
+    document.head.appendChild(style);
+  }
+
+  // src/audience/transparency.ts
+  var DISMISSED_KEY = "kywi_transparency_dismissed";
+  function isDismissed() {
+    return localStorage.getItem(DISMISSED_KEY) === "1";
+  }
+  function dismiss() {
+    localStorage.setItem(DISMISSED_KEY, "1");
+    removeBar();
+  }
+  function removeBar() {
+    document.querySelector(".kywi-transparency-bar")?.remove();
+  }
+  function optOut() {
+    setCookie(COOKIE_NAMES.OPTOUT, "1", 365 * 24 * 3600);
+    deleteCookie(COOKIE_NAMES.AUDIENCE);
+  }
+  function optIn() {
+    deleteCookie(COOKIE_NAMES.OPTOUT);
+  }
+  function createButton(className, text, onClick) {
+    const btn = document.createElement("button");
+    btn.className = className;
+    btn.type = "button";
+    btn.textContent = text;
+    btn.addEventListener("click", onClick);
+    return btn;
+  }
+  function renderTransparencyBar(state) {
+    removeBar();
+    if (isDismissed()) return;
+    if (state.isPersonalized && !state.isOptedOut || state.isOptedOut && state.hasMatchAvailable) {
+      ensureTransparencyStyles();
+    }
+    if (state.isPersonalized && !state.isOptedOut) {
+      const bar = document.createElement("div");
+      bar.className = "kywi-transparency-bar kywi-transparency-active";
+      bar.setAttribute("role", "status");
+      const text = document.createElement("span");
+      text.className = "kywi-transparency-text";
+      text.textContent = "This page has been personalized based on your browsing context.";
+      bar.appendChild(text);
+      bar.appendChild(createButton("kywi-transparency-opt-out", "Opt out", () => {
+        optOut();
+        window.location.reload();
+      }));
+      const dismissBtn = createButton("kywi-transparency-dismiss", "\u2715", () => dismiss());
+      dismissBtn.setAttribute("aria-label", "Dismiss");
+      bar.appendChild(dismissBtn);
+      document.body.appendChild(bar);
+    } else if (state.isOptedOut && state.hasMatchAvailable) {
+      const bar = document.createElement("div");
+      bar.className = "kywi-transparency-bar kywi-transparency-opted-out";
+      bar.setAttribute("role", "status");
+      const text = document.createElement("span");
+      text.className = "kywi-transparency-text";
+      text.textContent = "A personalized experience is available.";
+      bar.appendChild(text);
+      bar.appendChild(createButton("kywi-transparency-opt-in", "Enable", () => {
+        optIn();
+        window.location.reload();
+      }));
+      const dismissBtn = createButton("kywi-transparency-dismiss", "\u2715", () => dismiss());
+      dismissBtn.setAttribute("aria-label", "Dismiss");
+      bar.appendChild(dismissBtn);
+      document.body.appendChild(bar);
+    }
+  }
+
+  // src/audience/preview.ts
+  var PREVIEW_KEY = "kywi_preview_audience";
+  function getPreviewAudienceId() {
+    return sessionStorage.getItem(PREVIEW_KEY);
+  }
+  function setPreviewAudienceId(id) {
+    sessionStorage.setItem(PREVIEW_KEY, id);
+  }
+  function clearPreview() {
+    sessionStorage.removeItem(PREVIEW_KEY);
+  }
+  function checkPreviewInit() {
+    const cookies = readCookies();
+    const initId = cookies.get(COOKIE_NAMES.PREVIEW_INIT);
+    if (initId) {
+      setPreviewAudienceId(initId);
+      deleteCookie(COOKIE_NAMES.PREVIEW_INIT);
+    }
+  }
+  function renderPreviewBanner(audienceName) {
+    document.querySelector(".kywi-preview-banner")?.remove();
+    const banner = document.createElement("div");
+    banner.className = "kywi-preview-banner";
+    banner.setAttribute("role", "status");
+    const text = document.createElement("span");
+    text.className = "kywi-preview-text";
+    text.textContent = "Previewing as: ";
+    const strong = document.createElement("strong");
+    strong.textContent = audienceName;
+    text.appendChild(strong);
+    banner.appendChild(text);
+    const exitBtn = document.createElement("button");
+    exitBtn.className = "kywi-preview-exit";
+    exitBtn.type = "button";
+    exitBtn.textContent = "Exit Preview";
+    exitBtn.addEventListener("click", () => {
+      clearPreview();
+      window.location.reload();
+    });
+    banner.appendChild(exitBtn);
+    document.body.appendChild(banner);
+  }
+
+  // src/audience/data-layer.ts
+  function populateDataLayer(visitor) {
+    const g = window.kywi ?? {};
+    g.visitor = visitor;
+    window.kywi = g;
+  }
+  function fireKywiReady() {
+    window.dispatchEvent(new CustomEvent("kywiReady"));
+  }
+  function readServerMeta() {
+    const m = (n) => document.querySelector(`meta[name="kywi:${n}"]`)?.getAttribute("content") ?? null;
+    return { audienceId: m("audience-id"), experimentId: m("experiment-id"), variantId: m("variant-id"), visitorId: m("visitor-id") ?? "" };
+  }
+
+  // src/audience/adapter-runner.ts
+  var CACHE_PREFIX = "kywi_adapter_";
+  function getCached(adapterId) {
+    const raw = sessionStorage.getItem(CACHE_PREFIX + adapterId);
+    if (!raw) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  function setCache(adapterId, data) {
+    sessionStorage.setItem(CACHE_PREFIX + adapterId, JSON.stringify(data));
+  }
+  async function runClientAdapters(adapters, currentSignals, apiBase = "/api/v1") {
+    const merged = {};
+    const tasks = adapters.map(async (adapter) => {
+      const cached = getCached(adapter.id);
+      if (cached) return cached;
+      let result;
+      if (adapter.side === "server-proxy") {
+        const res = await fetch(`${apiBase}/kywi/adapters/${adapter.id}`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ signals: currentSignals })
+        });
+        const json = await res.json();
+        result = json.data ?? {};
+      } else {
+        result = await adapter.collect(currentSignals);
+      }
+      setCache(adapter.id, result);
+      return result;
+    });
+    const results = await Promise.all(tasks);
+    for (const r of results) Object.assign(merged, r);
+    return merged;
+  }
+
+  // src/audience/selfid-submit.ts
+  function handleSelfIdSubmit(responses, audiences, currentPath) {
+    storeSelfId(responses);
+    if (audiences && currentPath) {
+      const cookies = readCookies();
+      const serverMeta = readServerMeta();
+      const serverSignals = {
+        identity: { visitorId: serverMeta.visitorId || cookies.get(COOKIE_NAMES.VISITOR) || "", isKnown: cookies.has(COOKIE_NAMES.KNOWN), maLeadId: null },
+        meta: { isOptedOut: cookies.has(COOKIE_NAMES.OPTOUT), isPreview: false, previewAudienceId: null, resolvedAt: "server" }
+      };
+      const result = evaluateClientSide(audiences, serverSignals, currentPath);
+      patchVariantContainers(result.winningAudienceId);
+      populateDataLayer({
+        visitorId: result.signals.identity.visitorId,
+        audienceId: result.winningAudienceId,
+        experimentId: serverMeta.experimentId,
+        variantId: serverMeta.variantId,
+        isPreview: false,
+        isOptedOut: result.isOptedOut
+      });
+    }
+  }
+
+  // src/audience/selfid-widget.ts
+  var SHOWN_KEY = "kywi_selfid_shown";
+  var MS_PER_DAY = 864e5;
+  function createSelfIdWidget(config) {
+    const frequency = config.frequency ?? "once";
+    const displayMode = config.displayMode ?? "inline";
+    function shouldShow() {
+      if (frequency === "always") return true;
+      if (frequency === "session") return false;
+      const raw = localStorage.getItem(SHOWN_KEY);
+      if (!raw) return true;
+      if (frequency === "once") return false;
+      const ts = Number(raw);
+      return !isNaN(ts) && Date.now() - ts > MS_PER_DAY;
+    }
+    function markShown() {
+      localStorage.setItem(SHOWN_KEY, String(Date.now()));
+    }
+    function handleSubmit(responses) {
+      storeSelfId(responses);
+      handleSelfIdSubmit(responses, config.audiences ?? [], config.currentPath ?? "/");
+      markShown();
+    }
+    function render(container) {
+      container.replaceChildren();
+      container.className = `kywi-selfid-widget kywi-selfid-${displayMode}`;
+      if (config.headline) {
+        const h = document.createElement("h3");
+        h.className = "kywi-selfid-headline";
+        h.textContent = config.headline;
+        container.appendChild(h);
+      }
+      if (config.subheadline) {
+        const p = document.createElement("p");
+        p.className = "kywi-selfid-subheadline";
+        p.textContent = config.subheadline;
+        container.appendChild(p);
+      }
+      const form = document.createElement("form");
+      form.className = "kywi-selfid-form";
+      for (const field of config.fields) {
+        const fieldWrap = document.createElement("div");
+        fieldWrap.className = "kywi-selfid-field";
+        const label = document.createElement("label");
+        label.htmlFor = `kywi-field-${field.id}`;
+        label.textContent = field.label;
+        fieldWrap.appendChild(label);
+        let input;
+        if (field.type === "select") {
+          const select = document.createElement("select");
+          select.id = `kywi-field-${field.id}`;
+          select.name = field.id;
+          if (field.required) select.required = true;
+          if (field.options) {
+            const placeholder = document.createElement("option");
+            placeholder.value = "";
+            placeholder.textContent = "";
+            select.appendChild(placeholder);
+            for (const opt of field.options) {
+              const option = document.createElement("option");
+              option.value = opt;
+              option.textContent = opt;
+              select.appendChild(option);
+            }
+          }
+          input = select;
+        } else {
+          const inp = document.createElement("input");
+          inp.id = `kywi-field-${field.id}`;
+          inp.name = field.id;
+          inp.type = field.type;
+          if (field.required) inp.required = true;
+          input = inp;
+        }
+        fieldWrap.appendChild(input);
+        form.appendChild(fieldWrap);
+      }
+      const actions = document.createElement("div");
+      actions.className = "kywi-selfid-actions";
+      const submitBtn = document.createElement("button");
+      submitBtn.type = "submit";
+      submitBtn.className = "kywi-selfid-submit";
+      submitBtn.textContent = config.submitLabel ?? "Submit";
+      actions.appendChild(submitBtn);
+      if (config.skipLabel) {
+        const skipBtn = document.createElement("button");
+        skipBtn.type = "button";
+        skipBtn.className = "kywi-selfid-skip";
+        skipBtn.textContent = config.skipLabel;
+        skipBtn.addEventListener("click", () => {
+          markShown();
+          container.replaceChildren();
+        });
+        actions.appendChild(skipBtn);
+      }
+      form.appendChild(actions);
+      form.addEventListener("submit", (e) => {
+        e.preventDefault();
+        const data = new FormData(form);
+        const responses = {};
+        data.forEach((value, key) => {
+          responses[key] = String(value);
+        });
+        handleSubmit(responses);
+      });
+      container.appendChild(form);
+    }
+    return { shouldShow, markShown, render, handleSubmit };
+  }
+
+  // src/personalization/badge.ts
+  function isOptedOut() {
+    return readCookies().has(COOKIE_NAMES.OPTOUT);
+  }
+  function createButton2(className, text, onClick) {
+    const btn = document.createElement("button");
+    btn.className = className;
+    btn.type = "button";
+    btn.textContent = text;
+    btn.addEventListener("click", onClick);
+    return btn;
+  }
+  function renderPersonalizationBadge() {
+    const containers = document.querySelectorAll("[data-kywi-personalization-badge]");
+    if (containers.length === 0) return;
+    for (const container of Array.from(containers)) {
+      const existing = container.querySelector(".kywi-personalization-badge");
+      if (existing) existing.remove();
+      const badge = document.createElement("div");
+      badge.className = "kywi-personalization-badge";
+      const optedOut = isOptedOut();
+      const status = document.createElement("span");
+      status.className = "kywi-badge-status";
+      status.textContent = optedOut ? "Personalization disabled" : "Personalization active";
+      badge.appendChild(status);
+      if (optedOut) {
+        badge.appendChild(createButton2("kywi-badge-opt-in", "Opt in", () => {
+          deleteCookie(COOKIE_NAMES.OPTOUT);
+          renderPersonalizationBadge();
+        }));
+      } else {
+        badge.appendChild(createButton2("kywi-badge-opt-out", "Opt out", () => {
+          setCookie(COOKIE_NAMES.OPTOUT, "1", 365 * 24 * 3600);
+          deleteCookie(COOKIE_NAMES.AUDIENCE);
+          renderPersonalizationBadge();
+        }));
+      }
+      container.appendChild(badge);
+    }
+  }
+
+  // src/audience/index.ts
+  function resolveApiBase(explicit) {
+    if (explicit) return explicit;
+    const basePath = Kywi.context?.basePath;
+    if (!basePath || basePath === "/") return "/api/v1";
+    return `${basePath}/api/v1`;
+  }
+  async function bootAudienceEngine(config) {
+    const { audiences, currentPath, pageCategory, serverSignals } = config;
+    const apiBase = resolveApiBase(config.apiBase);
+    checkPreviewInit();
+    const serverMeta = readServerMeta();
+    const previewId = getPreviewAudienceId();
+    if (previewId) {
+      patchVariantContainers(previewId);
+      renderPreviewBanner(previewId);
+      renderPersonalizationBadge();
+      populateDataLayer({ visitorId: serverMeta.visitorId, audienceId: previewId, experimentId: null, variantId: null, isPreview: true, isOptedOut: false });
+      fireKywiReady();
+      return;
+    }
+    const cookies = readCookies();
+    let merged = {
+      ...serverSignals,
+      identity: { visitorId: serverMeta.visitorId || cookies.get(COOKIE_NAMES.VISITOR) || "", isKnown: cookies.has(COOKIE_NAMES.KNOWN), maLeadId: null },
+      meta: { isOptedOut: cookies.has(COOKIE_NAMES.OPTOUT), isPreview: false, previewAudienceId: null, resolvedAt: "server" }
+    };
+    if (config.adapters && config.adapters.length > 0) {
+      const adapterResults = await runClientAdapters(config.adapters, merged, apiBase);
+      merged.adapters = { ...merged.adapters, ...adapterResults };
+    }
+    const result = evaluateClientSide(audiences, merged, currentPath, pageCategory);
+    patchVariantContainers(result.winningAudienceId);
+    renderTransparencyBar({ isPersonalized: result.winningAudienceId !== null, isOptedOut: result.isOptedOut, hasMatchAvailable: result.allMatchedIds.length > 0 });
+    renderPersonalizationBadge();
+    populateDataLayer({ visitorId: result.signals.identity.visitorId, audienceId: result.winningAudienceId, experimentId: serverMeta.experimentId, variantId: serverMeta.variantId, isPreview: false, isOptedOut: result.isOptedOut });
+    fireKywiReady();
+    if (result.winningAudienceId && result.winningAudienceId !== serverMeta.audienceId) {
+      fetch(`${apiBase}/kywi/audience`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...Kywi.context?.csrfToken ? { "X-CSRF-Token": Kywi.context.csrfToken } : {} },
+        body: JSON.stringify({ audienceId: result.winningAudienceId })
+      }).catch(() => {
+      });
+    }
+    if (config.selfIdWidget) {
+      const widget = createSelfIdWidget(config.selfIdWidget);
+      if (widget.shouldShow()) {
+        const doRender = () => {
+          const existing = document.getElementById("kywi-selfid-container");
+          const container = existing ?? document.createElement("div");
+          if (!container.id) {
+            container.id = "kywi-selfid-container";
+            document.body.appendChild(container);
+          }
+          widget.render(container);
+        };
+        scheduleSelfIdWidget(config.selfIdWidget.trigger, doRender);
+      }
+    }
+  }
+  function scheduleSelfIdWidget(trigger, render) {
+    if (!trigger || trigger.type === "immediate") {
+      render();
+      return;
+    }
+    if (trigger.type === "manual") return;
+    if (trigger.type === "delay") {
+      window.setTimeout(render, Math.max(0, trigger.seconds) * 1e3);
+      return;
+    }
+    const target = Math.min(Math.max(trigger.depth, 0), 1);
+    let fired = false;
+    const onScroll = () => {
+      if (fired) return;
+      const scrollable = document.documentElement.scrollHeight - window.innerHeight;
+      const progress = scrollable > 0 ? window.scrollY / scrollable : 1;
+      if (progress >= target) {
+        fired = true;
+        window.removeEventListener("scroll", onScroll);
+        render();
+      }
+    };
+    window.addEventListener("scroll", onScroll, { passive: true });
+    onScroll();
+  }
+
+  // src/index.ts
+  var preInitCallbacks = [];
+  var booted = false;
+  var Kywi = {
+    version: "0.1.0",
+    context: null,
+    Module: {},
+    preInit(fn) {
+      if (booted) {
+        fn(Kywi);
+      } else {
+        preInitCallbacks.push(fn);
+      }
+    },
+    UI: {
+      extend(definition) {
+        return { ...definition };
+      }
+    },
+    DisplayObject: {
+      Form: {
+        _hooks: {},
+        extend(methods) {
+          Object.assign(Kywi.DisplayObject.Form._hooks, methods);
+        }
+      }
+    },
+    getEntity: null,
+    getFeed: null,
+    renderFeed: null,
+    boot() {
+      if (booted) return;
+      Kywi.context = readContext();
+      for (const fn of preInitCallbacks) {
+        fn(Kywi);
+      }
+      const basePath = Kywi.context.basePath === "/" ? "/api/v1" : `${Kywi.context.basePath}/api/v1`;
+      Kywi.getEntity = createEntityFactory(basePath, Kywi.context.csrfToken);
+      Kywi.getFeed = createFeedFactory(basePath, Kywi.context.csrfToken);
+      Kywi.renderFeed = renderFeed;
+      initModules();
+      initFormHooks();
+      bootExperiments({ context: Kywi.context });
+      booted = true;
+    }
+  };
+  if (typeof globalThis !== "undefined") {
+    globalThis.Kywi = Kywi;
+  }
+  if (typeof document !== "undefined") {
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => Kywi.boot());
+    } else {
+      Kywi.boot();
+    }
+  }
+  return __toCommonJS(src_exports);
+})();
+//# sourceMappingURL=kywi.js.map