@nurdd/web-sdk 1.0.0

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/integrations/shopify/README.md

@@ -0,0 +1,172 @@
+# Using Nurdd with Shopify
+
+Track marketing performance on your Shopify store — installs of intent
+(visits from campaigns), signups, and **purchases** — all attributed back to
+the Nurdd link a shopper originally clicked.
+
+You **don't** need a separate SDK. You reuse `@nurdd/web-sdk` on your
+storefront and add two small glue pieces for checkout, where the SDK can't
+run. Three steps, ~10 minutes.
+
+## What you get
+
+| Surface | What's tracked | How |
+| ------- | -------------- | --- |
+| Storefront (theme) | page views, events, signups, campaign landing | SDK in `theme.liquid` |
+| Checkout | purchases (client-side) | Custom Pixel |
+| Order (server) | purchases (reliable) | `orders/create` webhook |
+
+## Prerequisites
+
+- Your **public SDK key** (`sdk_pk_…`) and **API URL** from the Nurdd dashboard.
+- Access to your store's theme code (Online Store → Themes → Edit code).
+- For purchases: access to **Settings → Customer events** and/or the ability
+  to create a webhook (Settings → Notifications → Webhooks, or the Admin API).
+
+---
+
+## Step 1 — Storefront
+
+Add the SDK to your theme. Open `Online Store → Themes → … → Edit code →
+layout/theme.liquid` and paste this just before `</head>`:
+
+```html
+<script src="https://unpkg.com/@nurdd/web-sdk/dist/nurdd-sdk.umd.js"></script>
+<script>
+  var nurdd = Nurdd.initSdk({
+    sdkKey: "sdk_pk_xxx",
+    baseUrl: "https://api.nurdd.club",
+  });
+
+  // Tie activity to a logged-in customer.
+  {% if customer %}
+    nurdd.identify("{{ customer.id }}", { email: "{{ customer.email }}" });
+  {% endif %}
+
+  // Carry the campaign into checkout so the purchase can be attributed.
+  nurdd.attachToShopifyCart();
+</script>
+```
+
+**Routing campaign traffic:** point your Nurdd links so shoppers land on the
+store with the campaign code in the URL — either `?sdk_short_code=YOURCODE`
+or `?nurdd_shortcode=YOURCODE`. The SDK reads it on arrival, persists it, and
+`attachToShopifyCart()` writes it onto the cart so it survives all the way to
+the order.
+
+> **When to call `attachToShopifyCart()`:** any time before checkout — on page
+> load (as above) is fine, but calling it again right before "Add to cart"
+> guarantees the attribute is set even for shoppers who landed on a page with
+> an empty cart. It's a no-op when there's no campaign code, so it's safe to
+> call repeatedly.
+
+### Track events and signups
+
+```html
+<script>
+  // a custom event
+  nurdd.track("add_to_cart", { product_id: "{{ product.id }}" });
+
+  // a signup / account creation
+  nurdd.signup
+    ? nurdd.signup({ externalUserId: "{{ customer.id }}", email: "{{ customer.email }}" })
+    : nurdd.conversion("signup");
+</script>
+```
+
+---
+
+## Step 2 — Checkout pixel (client-side purchase)
+
+The full SDK can't run on Shopify's checkout (sandboxed — no
+`window`/`localStorage`), so use a small pixel instead:
+
+1. Go to **Settings → Customer events → Add custom pixel**, name it `Nurdd`.
+2. Paste the contents of [`checkout-pixel.js`](./checkout-pixel.js).
+3. Set `NURDD_API` and `SDK_KEY` at the top (and `CART_ATTRIBUTE` if you
+   changed the default).
+4. **Save**, then **Connect**.
+
+It fires a `purchase` conversion on `checkout_completed`, attributed to the
+campaign code stored on the cart.
+
+---
+
+## Step 3 — Order webhook (reliable purchase)
+
+Client pixels can be blocked by ad-blockers or fail to fire. For dependable
+revenue attribution, also record orders **server-side**:
+
+1. Create an **Order creation** (`orders/create`) webhook (JSON) pointing at
+   your backend route (Settings → Notifications → Webhooks, or the Admin API).
+2. Set `SHOPIFY_WEBHOOK_SECRET` in your backend environment.
+3. Use [`orders-webhook.example.js`](./orders-webhook.example.js) — it verifies
+   the Shopify HMAC, reads the campaign code from the order's `note_attributes`,
+   and records a `purchase` conversion. Plug in your own `recordConversion(...)`.
+
+Run the pixel **and** the webhook together: the pixel gives instant
+client-side data, the webhook guarantees you never miss a paid order.
+
+---
+
+## How attribution flows
+
+```
+Nurdd link  (?sdk_short_code=ABC)
+      │
+      ▼
+Storefront  ──  SDK persists "ABC"  ──  attachToShopifyCart() → cart attribute
+      │
+      ▼
+Checkout    ──  pixel reads cart attribute → purchase conversion (ABC)
+      │
+      ▼
+Order       ──  orders/create webhook reads attribute → purchase conversion (ABC)   ← reliable
+```
+
+---
+
+## Verify it's working
+
+1. **Storefront:** open your store with `?sdk_short_code=TEST123`, open the
+   browser console, and run `Nurdd.getSdk().attributedShortCode()` — it should
+   return `"TEST123"`.
+2. **Cart attribute:** add an item, then load `/cart.js` in the browser — you
+   should see `attributes: { nurdd_short_code: "TEST123" }`.
+3. **Pixel:** in Customer events, the pixel shows recent activity; complete a
+   test order and confirm a request to `/api/sdk/v1/conversions` fires.
+4. **Webhook:** check your backend logs for the `orders/create` delivery.
+
+## Troubleshooting
+
+| Symptom | Likely cause |
+| ------- | ------------ |
+| `attributedShortCode()` is `null` | The landing URL had no `sdk_short_code` / `nurdd_shortcode` param, or the SDK loaded after the redirect stripped it. |
+| Cart attribute missing on the order | `attachToShopifyCart()` ran before a cart existed — call it again at "Add to cart". |
+| Pixel fires but purchase isn't attributed | The cart attribute name in the pixel doesn't match `attachToShopifyCart()`'s (`nurdd_short_code`). |
+| Nothing recorded at all | The backend `/api/sdk/v1/conversions` endpoint must exist and accept your public key. |
+
+## Multiple campaigns
+
+A shopper can arrive via several Nurdd links before buying. `attachToShopifyCart()`
+**accumulates** the codes — the `nurdd_short_code` cart attribute holds a
+de-duplicated, comma-separated list in **first-touch → last-touch** order
+(e.g. `spring25,welcome10`). The checkout pixel and the webhook:
+
+- credit the purchase to the **last-touch** code by default (change to the
+  first element for first-touch), and
+- send the full list as `attribution.short_codes` so you can do multi-touch
+  attribution server-side.
+
+This avoids double-counting revenue (one purchase = one conversion) while
+preserving every campaign the shopper interacted with.
+
+## Notes
+
+- **Hydrogen (headless Shopify):** you don't need any of this — it's a normal
+  React/Remix app, so use `@nurdd/web-sdk/react` directly, checkout included.
+- **Standard vs. Plus:** these steps work on standard Shopify. Shopify Plus can
+  additionally customize checkout, but the pixel + webhook approach works on
+  both and is recommended.
+- The public SDK key is safe to expose in the theme and pixel — it's designed
+  to be client-side.

package/integrations/shopify/checkout-pixel.js

@@ -0,0 +1,63 @@
+// Nurdd × Shopify — Checkout pixel
+// =================================
+// The full Nurdd SDK can't run on Shopify's checkout (it's a sandboxed
+// environment with no window/localStorage). This small snippet does the one
+// job that matters there: record the purchase when an order completes.
+//
+// SETUP
+//   1. In Shopify admin: Settings → Customer events → Add custom pixel.
+//   2. Paste this file's contents, set NURDD_API + SDK_KEY below, Save & Connect.
+//
+// It reads the campaign code from the cart attribute that
+// `sdk.attachToShopifyCart()` set on the storefront, so the purchase is
+// attributed to the original campaign.
+
+const NURDD_API = "https://api.nurdd.club"; // your Nurdd API URL
+const SDK_KEY = "sdk_pk_xxx"; //              your public SDK key
+const CART_ATTRIBUTE = "nurdd_short_code"; //  must match attachToShopifyCart()
+
+analytics.subscribe("checkout_completed", (event) => {
+    const checkout = (event && event.data && event.data.checkout) || {};
+
+    // Custom cart attributes arrive as [{ key, value }, ...]. The shopper may
+    // have touched several campaigns, so the attribute holds a comma-separated
+    // list in first-touch → last-touch order.
+    const attributes = checkout.attributes || [];
+    const match = attributes.find((a) => a.key === CART_ATTRIBUTE);
+    const shortCodes = (match && match.value ? String(match.value).split(",") : [])
+        .map((s) => s.trim())
+        .filter(Boolean);
+
+    // Credit the purchase to the most recent campaign (last-touch). Switch to
+    // shortCodes[0] for first-touch. The full list is passed for multi-touch.
+    const primary = shortCodes.length ? shortCodes[shortCodes.length - 1] : null;
+
+    const total = checkout.totalPrice && checkout.totalPrice.amount;
+    const currency =
+        checkout.currencyCode ||
+        (checkout.totalPrice && checkout.totalPrice.currencyCode) ||
+        undefined;
+
+    fetch(`${NURDD_API}/api/sdk/v1/conversions`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-SDK-Key": SDK_KEY,
+            "X-SDK-Platform": "web",
+        },
+        keepalive: true,
+        body: JSON.stringify({
+            conversion_type: "purchase",
+            value: total != null ? Number(total) : undefined,
+            currency,
+            short_code: primary || undefined,
+            attribution: {
+                source: "shopify_checkout",
+                order_id: checkout.order && checkout.order.id,
+                short_codes: shortCodes, // every campaign touched, first → last
+            },
+        }),
+    }).catch(() => {
+        // Best-effort; the orders/create webhook is the reliable fallback.
+    });
+});

package/integrations/shopify/orders-webhook.example.js

@@ -0,0 +1,69 @@
+// Nurdd × Shopify — orders/create webhook (server-side)
+// =====================================================
+// The most reliable way to attribute Shopify purchases: it runs on your
+// backend, so it survives ad-blockers and the checkout sandbox entirely.
+// Shopify calls it on every new order; you read the campaign code that
+// `sdk.attachToShopifyCart()` stored and record a conversion.
+//
+// SETUP
+//   1. Shopify admin → Settings → Notifications → Webhooks (or via the API):
+//      create an "Order creation" webhook (JSON) pointing at this route.
+//   2. Set SHOPIFY_WEBHOOK_SECRET in your environment (the webhook's secret).
+//   3. Mount with a RAW body parser so HMAC verification works:
+//        app.post(
+//          "/webhooks/shopify/orders",
+//          express.raw({ type: "application/json" }),
+//          shopifyOrderWebhook
+//        );
+
+import crypto from "node:crypto";
+
+const CART_ATTRIBUTE = "nurdd_short_code"; // must match attachToShopifyCart()
+
+export function shopifyOrderWebhook(req, res) {
+    const secret = process.env.SHOPIFY_WEBHOOK_SECRET || "";
+    const sent = req.get("X-Shopify-Hmac-Sha256") || "";
+
+    // Verify the request really came from Shopify (HMAC over the raw body).
+    const digest = crypto.createHmac("sha256", secret).update(req.body).digest("base64");
+    const a = Buffer.from(sent);
+    const b = Buffer.from(digest);
+    if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
+        return res.status(401).send("invalid hmac");
+    }
+
+    let order;
+    try {
+        order = JSON.parse(req.body.toString("utf8"));
+    } catch {
+        return res.status(400).send("bad json");
+    }
+
+    // Cart attributes appear on the order as note_attributes [{ name, value }].
+    // The shopper may have touched several campaigns, so the value is a
+    // comma-separated list in first-touch → last-touch order.
+    const attrs = order.note_attributes || [];
+    const found = attrs.find((x) => x.name === CART_ATTRIBUTE);
+    const shortCodes = (found && found.value ? String(found.value).split(",") : [])
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const shortCode = shortCodes.length ? shortCodes[shortCodes.length - 1] : null; // last-touch
+
+    // --- Record the conversion ---------------------------------------------
+    // Plug in your attribution service / table here. Example shape:
+    //
+    //   await recordConversion({
+    //     conversionType: "purchase",
+    //     value: Number(order.total_price),
+    //     currency: order.currency,
+    //     shortCode,                 // attributes to the original campaign
+    //     externalUserId: order.customer?.id?.toString(),
+    //     email: order.email,
+    //     orderId: order.id,
+    //     occurredAt: order.created_at,
+    //   });
+    //
+    // Acknowledge fast (within Shopify's timeout); do heavy work async.
+
+    return res.status(200).send("ok");
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@nurdd/web-sdk",
+  "version": "1.0.0",
+  "description": "Framework-agnostic attribution & analytics SDK for the browser. Works with Vanilla JS, React, Next.js, Vue, Nuxt, Angular, Remix, and SvelteKit.",
+  "type": "module",
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "browser": "./dist/nurdd-sdk.umd.js",
+  "unpkg": "./dist/nurdd-sdk.umd.js",
+  "jsdelivr": "./dist/nurdd-sdk.umd.js",
+  "types": "./types/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "browser": "./dist/nurdd-sdk.umd.js",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./react": {
+      "types": "./types/react.d.ts",
+      "import": "./adapters/react.js",
+      "default": "./adapters/react.js"
+    },
+    "./vue": {
+      "types": "./types/vue.d.ts",
+      "import": "./adapters/vue.js",
+      "default": "./adapters/vue.js"
+    },
+    "./angular": {
+      "types": "./types/angular.d.ts",
+      "import": "./adapters/angular.js",
+      "default": "./adapters/angular.js"
+    },
+    "./next": {
+      "types": "./types/next.d.ts",
+      "import": "./adapters/next.js",
+      "default": "./adapters/next.js"
+    },
+    "./nuxt": {
+      "types": "./types/nuxt.d.ts",
+      "import": "./adapters/nuxt.js",
+      "default": "./adapters/nuxt.js"
+    },
+    "./umd": "./dist/nurdd-sdk.umd.js"
+  },
+  "files": [
+    "src",
+    "adapters",
+    "dist",
+    "types",
+    "integrations",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node scripts/build-umd.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "attribution",
+    "analytics",
+    "tracking",
+    "sdk",
+    "deep-link",
+    "campaign",
+    "referral",
+    "react",
+    "vue",
+    "angular",
+    "next",
+    "nuxt",
+    "remix"
+  ],
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "vue": ">=3.0.0",
+    "@angular/core": ">=12.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": { "optional": true },
+    "vue": { "optional": true },
+    "@angular/core": { "optional": true }
+  },
+  "license": "MIT"
+}

package/src/autotrack.js

@@ -0,0 +1,88 @@
+import { isBrowser } from "./env.js";
+
+// Wires up automatic event tracking that every framework benefits from:
+//
+//  - SPA page views: works for React Router, Vue Router, Next.js, Nuxt,
+//    Angular, Remix etc. by monkey-patching `history.pushState` and
+//    `history.replaceState` and listening to `popstate`.
+//  - Outbound clicks: any `<a>` whose href leaves the current origin.
+//  - Page unload: flush queued events via the beacon channel.
+//
+// All of this is opt-in via `config.autotrack`.
+
+export function setupAutotrack({ sdk, config, queue, logger }) {
+    if (!isBrowser) return () => {};
+    const offFns = [];
+
+    if (config.autotrack.pageViews !== false) {
+        offFns.push(trackPageViews(sdk));
+    }
+    if (config.autotrack.outboundClicks) {
+        offFns.push(trackOutboundClicks(sdk));
+    }
+    if (config.autotrack.flushOnUnload !== false) {
+        offFns.push(flushOnUnload(queue));
+    }
+
+    return () => offFns.forEach((fn) => { try { fn(); } catch (e) { logger.warn(e); } });
+}
+
+function trackPageViews(sdk) {
+    const fire = () => {
+        sdk.track("page_view", {
+            url: window.location.href,
+            path: window.location.pathname,
+            search: window.location.search,
+            title: typeof document !== "undefined" ? document.title : null,
+            referrer: typeof document !== "undefined" ? document.referrer || null : null,
+        });
+    };
+    // Initial view.
+    fire();
+
+    const origPush = history.pushState;
+    const origReplace = history.replaceState;
+    history.pushState = function (...args) {
+        const r = origPush.apply(this, args);
+        queueMicrotask(fire);
+        return r;
+    };
+    history.replaceState = function (...args) {
+        const r = origReplace.apply(this, args);
+        queueMicrotask(fire);
+        return r;
+    };
+    window.addEventListener("popstate", fire);
+    return () => {
+        history.pushState = origPush;
+        history.replaceState = origReplace;
+        window.removeEventListener("popstate", fire);
+    };
+}
+
+function trackOutboundClicks(sdk) {
+    const handler = (e) => {
+        const a = e.target?.closest?.("a[href]");
+        if (!a) return;
+        let host = "";
+        try { host = new URL(a.href, window.location.href).host; } catch { return; }
+        if (!host || host === window.location.host) return;
+        sdk.track("outbound_click", { url: a.href, text: (a.textContent || "").trim().slice(0, 256) });
+    };
+    document.addEventListener("click", handler, { capture: true });
+    return () => document.removeEventListener("click", handler, { capture: true });
+}
+
+function flushOnUnload(queue) {
+    const handler = () => queue.flushBeacon();
+    // `pagehide` is preferred over `unload` (works on bfcache).
+    window.addEventListener("pagehide", handler);
+    window.addEventListener("beforeunload", handler);
+    document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") queue.flushBeacon();
+    });
+    return () => {
+        window.removeEventListener("pagehide", handler);
+        window.removeEventListener("beforeunload", handler);
+    };
+}

package/src/deeplinks.js

@@ -0,0 +1,79 @@
+import { isBrowser } from "./env.js";
+import { readUtmFromLocation } from "./utm.js";
+
+// Deferred deep link resolver. On first launch / first SDK init, asks
+// the backend "did this device just click a short link that hasn't yet
+// been claimed?" If yes, the listener receives the deep link path and
+// the host app routes to it.
+//
+// Resolution sources, in priority order:
+//   1. UTM params on the current URL (short_code present) → server claim
+//   2. Fingerprint match via /links/deferred
+
+export class DeepLinkResolver {
+    constructor({ transport, logger }) {
+        this.transport = transport;
+        this.logger = logger;
+        this.listeners = new Set();
+        this.lastResolved = null;
+    }
+
+    onResolved(listener) {
+        this.listeners.add(listener);
+        // Fire late subscribers with the cached value so framework
+        // adapters don't miss the first resolution.
+        if (this.lastResolved) {
+            try { listener(this.lastResolved); } catch (e) { this.logger.warn("deep link listener threw", e); }
+        }
+        return () => this.listeners.delete(listener);
+    }
+
+    async resolve({ device }) {
+        const params = isBrowser ? readUtmFromLocation() : {};
+        let resolved = null;
+
+        if (params.short_code) {
+            const link = await this.transport.request(`/api/sdk/v1/links/${encodeURIComponent(params.short_code)}`);
+            if (link.ok && link.data?.link) {
+                resolved = {
+                    short_code: link.data.link.short_code,
+                    deep_link_path: link.data.link.deep_link_path || null,
+                    destination_url: link.data.link.destination_url || null,
+                    utm: link.data.link.utm || {},
+                    metadata: link.data.link.metadata || {},
+                    source: "url",
+                };
+            }
+        }
+
+        if (!resolved) {
+            const res = await this.transport.request("/api/sdk/v1/links/deferred", {
+                method: "POST",
+                body: {
+                    short_code: params.short_code || "__resolve__",
+                    platform: "web",
+                    device_id: device?.device_id,
+                },
+            });
+            if (res.ok && res.data?.deferred_deep_link) {
+                const d = res.data.deferred_deep_link;
+                resolved = {
+                    short_code: d.short_code,
+                    deep_link_path: d.deep_link_path,
+                    destination_url: null,
+                    utm: {},
+                    metadata: {},
+                    source: "deferred",
+                };
+            }
+        }
+
+        if (resolved) {
+            this.lastResolved = resolved;
+            for (const l of this.listeners) {
+                try { l(resolved); } catch (e) { this.logger.warn("deep link listener threw", e); }
+            }
+        }
+        return resolved;
+    }
+}

package/src/device.js

@@ -0,0 +1,78 @@
+import { isBrowser, SDK_VERSION } from "./env.js";
+import { uuid, fnv1a } from "./utils.js";
+
+const DEVICE_ID_KEY = "device_id";
+
+// Builds the device payload the backend expects on every event. The
+// backend re-validates and fills in anything we miss server-side.
+export function collectDevice({ storage, appVersion }) {
+    let deviceId = storage.getString(DEVICE_ID_KEY);
+    if (!deviceId) {
+        deviceId = uuid();
+        storage.setString(DEVICE_ID_KEY, deviceId);
+    }
+
+    if (!isBrowser) {
+        return {
+            device_id: deviceId,
+            platform: "server",
+            sdk_version: SDK_VERSION,
+            app_version: appVersion || null,
+        };
+    }
+
+    const nav = window.navigator || {};
+    const screen = window.screen || {};
+    const locale = nav.language || nav.userLanguage || null;
+    let timezone = null;
+    try { timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || null; } catch { /* ignore */ }
+
+    return {
+        device_id: deviceId,
+        platform: "web",
+        os_name: parseOsName(nav.userAgent || ""),
+        os_version: null,
+        model: null,
+        manufacturer: null,
+        app_version: appVersion || null,
+        sdk_version: SDK_VERSION,
+        locale,
+        timezone,
+        attributes: {
+            user_agent: nav.userAgent || null,
+            screen: `${screen.width || 0}x${screen.height || 0}`,
+            viewport: `${window.innerWidth || 0}x${window.innerHeight || 0}`,
+            color_depth: screen.colorDepth || null,
+            pixel_ratio: window.devicePixelRatio || 1,
+            hardware_concurrency: nav.hardwareConcurrency || null,
+            do_not_track: nav.doNotTrack === "1" || nav.doNotTrack === "yes",
+        },
+    };
+}
+
+function parseOsName(ua) {
+    if (/Windows NT/i.test(ua)) return "Windows";
+    if (/Mac OS X/i.test(ua)) return "macOS";
+    if (/Android/i.test(ua)) return "Android";
+    if (/iPhone|iPad|iPod/i.test(ua)) return "iOS";
+    if (/Linux/i.test(ua)) return "Linux";
+    if (/CrOS/i.test(ua)) return "ChromeOS";
+    return null;
+}
+
+// Local fingerprint hint. The server computes the authoritative
+// fingerprint from IP+UA, but we provide a stable client value so
+// clicks and installs can also match in pure-frontend flows.
+export function clientFingerprint(device) {
+    const a = device.attributes || {};
+    return fnv1a([
+        device.platform,
+        device.os_name,
+        device.locale,
+        device.timezone,
+        a.screen,
+        a.color_depth,
+        a.pixel_ratio,
+        a.hardware_concurrency,
+    ].join("|"));
+}

package/src/env.js

@@ -0,0 +1,21 @@
+// Runtime detection so the same module works in browsers, SSR, web workers,
+// React Native (via metro shimming `window`), and any other JS host.
+export const isBrowser =
+    typeof window !== "undefined" &&
+    typeof document !== "undefined" &&
+    typeof navigator !== "undefined";
+
+export const hasLocalStorage = (() => {
+    try {
+        if (!isBrowser) return false;
+        const k = "__nurdd_probe__";
+        window.localStorage.setItem(k, "1");
+        window.localStorage.removeItem(k);
+        return true;
+    } catch {
+        return false;
+    }
+})();
+
+export const SDK_NAME = "web";
+export const SDK_VERSION = "1.0.0";