@heyramzi/utils 0.0.0-stage → 1.13.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ramzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,113 @@
-# Temporary Holding Version
+> [!IMPORTANT]
+> This submodule is originally created and maintained in `Studio/vibe-kit/modules`. Changes should be made and pushed from there. We are the creators and maintainers of this submodule.
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @heyramzi/utils
+
+Shared utility functions used across all workspace projects.
+
+## Install
+
+```bash
+pnpm add @heyramzi/utils
+```
+
+In the workspace, use `"@heyramzi/utils": "workspace:*"` in your `package.json`.
+
+## Exports
+
+### Main entry (`.`)
+
+All utilities re-exported from a single barrel:
+
+```ts
+import { cn, formatDate, debounce, groupBy } from "@heyramzi/utils";
+```
+
+### Subpath exports
+
+Some modules are also a direct import for tree-shaking. The rest come from the barrel only.
+
+| Subpath | Exports |
+| --- | --- |
+| `@heyramzi/utils/cn` | `cn`, `WithElementRef`, `WithoutChild`, `WithoutChildren`, `WithoutChildrenOrChild` |
+| `@heyramzi/utils/format` | `formatDate`, `formatCurrency`, `formatAmount`, `formatMillisecondsToHours`, `formatRelativeTime` |
+| `@heyramzi/utils/string` | `slugify`, `generateSlug`, `buildSearchParams`, `parseJSON`, `parseCommaSeparatedList`, `matchesQuery` |
+| `@heyramzi/utils/timing` | `debounce`, `throttle`, `sleep` |
+| `@heyramzi/utils/math` | `clamp` |
+| `@heyramzi/utils/collection` | `groupBy` |
+| `@heyramzi/utils/result` | `Ok`, `Err`, `tryCatch`, `tryCatchAsync`, `Result` |
+| `@heyramzi/utils/crypto` | `encryptSecret`, `decryptSecret`, `encryptSecretWithKey`, `decryptSecretWithKey`, `packSecret`, `unpackSecret`, `SecretCiphertext` |
+| `@heyramzi/utils/vite` | `packageImportsOverKitAlias`, `reclaimPort` |
+| `@heyramzi/utils/grab` | Side effect only: `if (dev) import("@heyramzi/utils/grab")`, then Alt+Click copies an element's HTML and Svelte component stack |
+
+Barrel only: `fetchApi`, `isCacheExpired`, `setLogger`, `log`.
+
+## Usage in projects
+
+Projects re-export what they need from their own `src/lib/utils.ts`:
+
+```ts
+// src/lib/utils.ts
+export { cn, formatDate, formatRelativeTime, debounce } from "@heyramzi/utils";
+export type { WithoutChild, WithoutChildren, WithElementRef } from "@heyramzi/utils";
+```
+
+This keeps the public API stable per-project while sourcing from a single implementation.
+
+## Logger
+
+`log()` does nothing until an app calls `setLogger()` once at startup with an implementation of the `Logger` interface. It never throws.
+
+## Secret Encryption
+
+`@heyramzi/utils/crypto` exists for reversible encryption of OAuth tokens and API keys at rest in app backends. It does not store anything for you and it does not implement provider-specific auth flows.
+
+Import it as a server-only subpath:
+
+```ts
+import { decryptSecret, encryptSecret } from "@heyramzi/utils/crypto";
+```
+
+It uses AES-256-GCM with:
+
+- a 32-byte master key from `HEYRAMZI_UTILS_CRYPTO_KEY`
+- a fresh random 12-byte IV for every encryption
+- base64 output for both `ciphertext` and `iv`
+
+`ciphertext` includes the GCM auth tag, so consumers only need to persist `ciphertext` and `iv`. Use this helper only when the secret must be recovered later. It is not for password storage or hashing.
+
+If an app already has its own env var name or stores encrypted secrets in a single database field, use the additive helpers:
+
+- `encryptSecretWithKey` / `decryptSecretWithKey` to pass a raw 32-byte key directly
+- `packSecret` / `unpackSecret` to bridge `{ ciphertext, iv }` with a single base64 payload
+
+## Dependencies
+
+- `clsx` + `tailwind-merge` (for `cn`)
+- `vite` (optional peer, only for `@heyramzi/utils/vite`)
+
+## Tooling scripts
+
+This package hosts two code-intelligence CLIs as devDependencies, invoked from the utils package so they have a stable home. They are not part of the runtime library surface.
+
+| Script         | Command                     | What it does                                                                                                                                                                    |
+| -------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `pnpm fallow`  | [`fallow`][fallow]          | Static analysis for TypeScript/JavaScript: unused files/exports/deps, circular references, copy-pasted blocks, complexity hotspots, architecture boundary drift.                |
+| `pnpm shannon` | [`@keygraph/shannon`][shan] | Autonomous AI pentester for web apps and APIs. Reads a source checkout, runs exploits against a live URL, reports only verified vulnerabilities. Requires Docker and Node 18+. |
+
+Run from `packages/utils`:
+
+```bash
+pnpm fallow                 # summary across the codebase
+pnpm fallow dead-code       # just unused code
+pnpm fallow audit --format json
+pnpm shannon setup
+pnpm shannon start -u https://example.com -r /path/to/repo
+```
+
+[fallow]: https://github.com/fallow-rs/fallow
+[shan]: https://github.com/KeygraphHQ/shannon
+
+## Removed
+
+The `error-reporter`, `image` and `sveltekit` modules are gone, along with `getErrorMessage`, `CACHE_TTL`, `getCacheExpiry`, `getLogger` and `formatTime`. Nothing imported them, and the `sharp` and SvelteKit peers went with them.

package/dist/ai/image.js

@@ -0,0 +1,220 @@
+import { generateText } from "ai";
+import { gatewayId, IMAGE_OUTPUT_TOKEN_PRICE_USD, resolveImageModelConfig } from "./models.js";
+function providerOptions(config, aspectRatio) {
+    if (config.provider !== "google") {
+        throw new Error(`Provider "${config.provider}" has no image request shape in @heyramzi/utils.`);
+    }
+    return {
+        google: {
+            responseModalities: [
+                "IMAGE"
+            ],
+            ...aspectRatio ? {
+                imageConfig: {
+                    aspectRatio
+                }
+            } : {}
+        }
+    };
+}
+function decodeBase64(value) {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for(let index = 0; index < binary.length; index++)bytes[index] = binary.charCodeAt(index);
+    return bytes;
+}
+const OPENAI_QUALITY = {
+    small: "low",
+    medium: "medium",
+    large: "high"
+};
+const OPENAI_SIZE_BY_RATIO = {
+    "16:9": "1536x1024",
+    "3:2": "1536x1024",
+    "1:1": "1024x1024",
+    "2:3": "1024x1536",
+    "9:16": "1024x1536"
+};
+function openAiCost(config, outputTokens) {
+    const perToken = IMAGE_OUTPUT_TOKEN_PRICE_USD[config.modelId];
+    if (!perToken || !outputTokens) return config.pricePerImage;
+    return outputTokens * perToken;
+}
+function openAiKey(explicit) {
+    const env = globalThis.process?.env;
+    const apiKey = explicit ?? env?.OPENAI_API_KEY;
+    if (!apiKey) throw new Error("OPENAI_API_KEY is not set, so no OpenAI image can be drawn.");
+    return apiKey;
+}
+async function postOpenAi(path, body, headers, apiKey) {
+    const response = await fetch(`https://api.openai.com/v1/${path}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            ...headers
+        },
+        body
+    });
+    const json = await response.json().catch(()=>({}));
+    return {
+        ok: response.ok,
+        status: response.status,
+        json
+    };
+}
+async function generateOpenAiImage(config, options, tier) {
+    const size = options.size ?? OPENAI_SIZE_BY_RATIO[options.aspectRatio ?? ""] ?? "auto";
+    const quality = OPENAI_QUALITY[tier];
+    const references = options.references ?? [];
+    const apiKey = openAiKey(options.apiKey);
+    async function call(withFidelity) {
+        if (references.length === 0) {
+            return postOpenAi("images/generations", JSON.stringify({
+                model: config.sdkId,
+                prompt: options.prompt,
+                size,
+                quality,
+                n: 1
+            }), {
+                "Content-Type": "application/json"
+            }, apiKey);
+        }
+        const form = new FormData();
+        form.set("model", config.sdkId);
+        form.set("prompt", options.prompt);
+        form.set("size", size);
+        form.set("quality", quality);
+        form.set("n", "1");
+        if (withFidelity) form.set("input_fidelity", "high");
+        for (const [index, reference] of references.entries()){
+            const extension = reference.mediaType.split("/")[1] ?? "png";
+            form.append("image[]", new Blob([
+                reference.bytes
+            ], {
+                type: reference.mediaType
+            }), `reference-${index + 1}.${extension}`);
+        }
+        return postOpenAi("images/edits", form, {}, apiKey);
+    }
+    let result = await call(references.length > 0);
+    const unknownParam = !result.ok && (result.json.error?.message ?? "").includes("input_fidelity");
+    if (unknownParam) result = await call(false);
+    if (!result.ok) {
+        throw new Error(`${config.modelId} refused the request (${result.status}): ${result.json.error?.message ?? "no message"}`);
+    }
+    const base64 = result.json.data?.[0]?.b64_json;
+    if (!base64) throw new Error(`${config.modelId} returned no image data.`);
+    return {
+        bytes: decodeBase64(base64),
+        mediaType: "image/png",
+        config,
+        priceUsd: openAiCost(config, result.json.usage?.output_tokens),
+        attempts: 1
+    };
+}
+const AGNES_SIZE = {
+    small: "1K",
+    medium: "2K",
+    large: "4K"
+};
+const AGNES_BASE_URL = "https://apihub.agnes-ai.com/v1";
+function agnesKey(explicit) {
+    const env = globalThis.process?.env;
+    const key = explicit ?? env?.AGNES_API_KEY;
+    if (!key) {
+        throw new Error("The agnes image lane needs an API key: pass `apiKey`, or set AGNES_API_KEY.");
+    }
+    return key;
+}
+async function generateAgnesImage(config, options, tier) {
+    const references = options.references ?? [];
+    if (references.length > 0) {
+        throw new Error(`${config.modelId} draws from a prompt only: it refuses a reference image with a 403 that blames the model. Draw through a gateway for anything conditioned on a frame.`);
+    }
+    const body = {
+        model: config.sdkId,
+        prompt: options.prompt,
+        size: options.size ?? AGNES_SIZE[tier],
+        ratio: options.aspectRatio ?? "1:1"
+    };
+    const response = await fetch(`${AGNES_BASE_URL}/images/generations`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${agnesKey(options.apiKey)}`,
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+    });
+    const json = await response.json().catch(()=>({}));
+    if (!response.ok) {
+        throw new Error(`${config.modelId} refused the request (${response.status}): ${json.error?.message ?? json.message ?? "no message"}`);
+    }
+    const first = json.data?.[0];
+    if (first?.b64_json) {
+        return {
+            bytes: decodeBase64(first.b64_json),
+            mediaType: "image/png",
+            config,
+            priceUsd: config.pricePerImage,
+            attempts: 1
+        };
+    }
+    if (first?.url) {
+        const image = await fetch(first.url);
+        if (!image.ok) {
+            throw new Error(`${config.modelId} returned a url that did not fetch (${image.status}).`);
+        }
+        return {
+            bytes: new Uint8Array(await image.arrayBuffer()),
+            mediaType: image.headers.get("content-type") ?? "image/png",
+            config,
+            priceUsd: config.pricePerImage,
+            attempts: 1
+        };
+    }
+    throw new Error(`${config.modelId} returned no image data.`);
+}
+export async function generateImage(options) {
+    const tier = options.tier ?? "medium";
+    const config = resolveImageModelConfig(tier, options.provider);
+    if (config.provider === "openai") return generateOpenAiImage(config, options, tier);
+    if (config.provider === "agnes") return generateAgnesImage(config, options, tier);
+    const id = gatewayId(config);
+    const model = options.gateway ? options.gateway(id) : id;
+    const attempts = options.attempts ?? 3;
+    let lastText = "";
+    for(let attempt = 1; attempt <= attempts; attempt++){
+        const result = await generateText({
+            model,
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "text",
+                            text: options.prompt
+                        },
+                        ...(options.references ?? []).map((reference)=>({
+                                type: "file",
+                                data: reference.bytes,
+                                mediaType: reference.mediaType
+                            }))
+                    ]
+                }
+            ],
+            providerOptions: providerOptions(config, options.aspectRatio)
+        });
+        const file = result.files.find((entry)=>entry.mediaType.startsWith("image/"));
+        if (file) {
+            return {
+                bytes: file.uint8Array,
+                mediaType: file.mediaType,
+                config,
+                priceUsd: config.pricePerImage,
+                attempts: attempt
+            };
+        }
+        lastText = (result.text ?? "").slice(0, 160);
+    }
+    throw new Error(`${config.modelId} returned no image after ${attempts} attempts${lastText ? `: ${lastText}` : ""}`);
+}

package/dist/ai/models.js

@@ -0,0 +1,261 @@
+export const MODEL_IDS = {
+    xai: {
+        large: "grok-4.7",
+        medium: "grok-4.7",
+        small: "grok-4.7"
+    },
+    google: {
+        large: "gemini-3.8-flash",
+        medium: "gemini-3.8-flash",
+        small: "gemini-3.5-flash-lite"
+    },
+    anthropic: {
+        large: "claude-opus-5-5",
+        medium: "claude-sonnet-5-5",
+        small: "claude-haiku-5-5"
+    },
+    groq: {
+        large: "openai/gpt-oss-120b",
+        medium: "openai/gpt-oss-120b",
+        small: "openai/gpt-oss-20b"
+    }
+};
+export const MODEL_CATALOG = {
+    "grok-4.7": {
+        modelId: "grok-4.7",
+        sdkId: "grok-4.7",
+        provider: "xai",
+        tier: "large",
+        pricing: {
+            input: 2.0,
+            output: 6.0
+        },
+        gatewayId: "spacexai/grok-4.7"
+    },
+    "gemini-3.8-flash": {
+        modelId: "gemini-3.8-flash",
+        sdkId: "gemini-3.8-flash",
+        provider: "google",
+        tier: "medium",
+        pricing: {
+            input: 1.5,
+            output: 7.5
+        }
+    },
+    "gemini-3.5-flash-lite": {
+        modelId: "gemini-3.5-flash-lite",
+        sdkId: "gemini-3.5-flash-lite",
+        provider: "google",
+        tier: "small",
+        pricing: {
+            input: 0.3,
+            output: 2.5
+        }
+    },
+    "claude-opus-5-5": {
+        modelId: "claude-opus-5-5",
+        sdkId: "claude-opus-5-5",
+        gatewayId: "anthropic/claude-opus-5.5",
+        provider: "anthropic",
+        tier: "large",
+        pricing: {
+            input: 4.0,
+            output: 20.0
+        }
+    },
+    "claude-sonnet-5-5": {
+        modelId: "claude-sonnet-5-5",
+        sdkId: "claude-sonnet-5-5",
+        gatewayId: "anthropic/claude-sonnet-5.5",
+        provider: "anthropic",
+        tier: "medium",
+        pricing: {
+            input: 2.0,
+            output: 10.0
+        }
+    },
+    "claude-haiku-5-5": {
+        modelId: "claude-haiku-5-5",
+        sdkId: "claude-haiku-5-5",
+        gatewayId: "anthropic/claude-haiku-5.5",
+        provider: "anthropic",
+        tier: "small",
+        pricing: {
+            input: 0.1,
+            output: 0.5
+        }
+    },
+    "claude-fable-5-1": {
+        modelId: "claude-fable-5-1",
+        sdkId: "claude-fable-5-1",
+        gatewayId: "anthropic/claude-fable-5.1",
+        provider: "anthropic",
+        tier: "large",
+        pricing: {
+            input: 10.0,
+            output: 50.0
+        }
+    },
+    "gemini-3.6-flash": {
+        modelId: "gemini-3.6-flash",
+        sdkId: "gemini-3.6-flash",
+        provider: "google",
+        tier: "medium",
+        pricing: {
+            input: 1.5,
+            output: 7.5
+        }
+    },
+    "gpt-5.6-luna": {
+        modelId: "gpt-5.6-luna",
+        sdkId: "gpt-5.6-luna",
+        provider: "openai",
+        tier: "small",
+        pricing: {
+            input: 0.2,
+            output: 1.2
+        }
+    },
+    "gpt-6-luna": {
+        modelId: "gpt-6-luna",
+        sdkId: "gpt-6-luna",
+        provider: "openai",
+        tier: "small",
+        pricing: {
+            input: 0.1,
+            output: 0.5
+        }
+    },
+    "gpt-6.1-sol": {
+        modelId: "gpt-6.1-sol",
+        sdkId: "gpt-6.1-sol",
+        provider: "openai",
+        tier: "large",
+        pricing: {
+            input: 2.0,
+            output: 10.0
+        }
+    },
+    "openai/gpt-oss-120b": {
+        modelId: "openai/gpt-oss-120b",
+        sdkId: "openai/gpt-oss-120b",
+        gatewayId: "openai/gpt-oss-120b",
+        provider: "groq",
+        tier: "large",
+        pricing: {
+            input: 0.15,
+            output: 0.6
+        }
+    },
+    "openai/gpt-oss-20b": {
+        modelId: "openai/gpt-oss-20b",
+        sdkId: "openai/gpt-oss-20b",
+        gatewayId: "openai/gpt-oss-20b",
+        provider: "groq",
+        tier: "small",
+        pricing: {
+            input: 0.075,
+            output: 0.3
+        }
+    }
+};
+export const DEFAULT_PROVIDER = "xai";
+export const EMBEDDING_MODEL = {
+    modelId: "gemini-embedding-2-preview",
+    gatewayId: "google/gemini-embedding-2",
+    provider: "google",
+    dimensions: 768
+};
+export const EMBEDDING_DIMENSIONS = EMBEDDING_MODEL.dimensions;
+export function gatewayId(config) {
+    return config.gatewayId ?? `${config.provider}/${config.sdkId}`;
+}
+export function getModelConfig(id) {
+    const config = MODEL_CATALOG[id];
+    if (!config) {
+        throw new Error(`Missing model config for model "${id}".`);
+    }
+    return config;
+}
+export function resolveModelConfig(tier, provider = DEFAULT_PROVIDER) {
+    const ids = MODEL_IDS;
+    const modelId = ids[provider]?.[tier];
+    if (!modelId) {
+        throw new Error(`Missing model ID for provider "${provider}" and tier "${tier}".`);
+    }
+    return getModelConfig(modelId);
+}
+export function model(tier, provider = DEFAULT_PROVIDER) {
+    return gatewayId(resolveModelConfig(tier, provider));
+}
+export const IMAGE_MODEL_IDS = {
+    google: {
+        small: "gemini-3.1-flash-lite-image",
+        medium: "gemini-3.1-flash-lite-image",
+        large: "gemini-nano-banana-2.1"
+    },
+    openai: {
+        small: "gpt-image-2",
+        medium: "gpt-image-2",
+        large: "gpt-image-2"
+    },
+    agnes: {
+        small: "agnes-image-2.5-flash",
+        medium: "agnes-image-2.5-flash",
+        large: "agnes-image-2.5-flash"
+    }
+};
+export const IMAGE_MODEL_CATALOG = {
+    "gemini-3.1-flash-lite-image": {
+        modelId: "gemini-3.1-flash-lite-image",
+        sdkId: "gemini-3.1-flash-lite-image",
+        provider: "google",
+        tier: "small",
+        pricePerImage: 0.034
+    },
+    "gemini-nano-banana-2.1": {
+        modelId: "gemini-nano-banana-2.1",
+        sdkId: "gemini-nano-banana-2.1",
+        provider: "google",
+        tier: "large",
+        pricePerImage: 0.067
+    },
+    "gemini-3-pro-image": {
+        modelId: "gemini-3-pro-image",
+        sdkId: "gemini-3-pro-image",
+        provider: "google",
+        tier: "large",
+        pricePerImage: 0.134
+    },
+    "gpt-image-2": {
+        modelId: "gpt-image-2",
+        sdkId: "gpt-image-2",
+        provider: "openai",
+        tier: "medium",
+        pricePerImage: 0.032
+    },
+    "agnes-image-2.5-flash": {
+        modelId: "agnes-image-2.5-flash",
+        sdkId: "agnes-image-2.5-flash",
+        provider: "agnes",
+        tier: "medium",
+        pricePerImage: 0
+    }
+};
+export const IMAGE_OUTPUT_TOKEN_PRICE_USD = {
+    "gpt-image-2": 30 / 1_000_000
+};
+export const DEFAULT_IMAGE_PROVIDER = "google";
+export function resolveImageModelConfig(tier, provider = DEFAULT_IMAGE_PROVIDER) {
+    const modelId = IMAGE_MODEL_IDS[provider]?.[tier];
+    const config = modelId ? IMAGE_MODEL_CATALOG[modelId] : undefined;
+    if (!config) {
+        throw new Error(`Missing image model for provider "${provider}" and tier "${tier}".`);
+    }
+    return config;
+}
+export function imagePriceUsd(modelId) {
+    const direct = IMAGE_MODEL_CATALOG[modelId];
+    if (direct) return direct.pricePerImage;
+    return Object.values(IMAGE_MODEL_CATALOG).find((config)=>config.sdkId === modelId)?.pricePerImage ?? null;
+}

package/dist/analytics/client.js

@@ -0,0 +1,57 @@
+import "./types.js";
+let active = false;
+export function initAnalytics(config) {
+    stop();
+    if (config.disabled || typeof window === "undefined") return stop;
+    active = true;
+    injectScript(config);
+    return stop;
+}
+function stop() {
+    active = false;
+}
+export function track(event, meta) {
+    if (!active || typeof window === "undefined" || !window.umami) return;
+    try {
+        if (meta) {
+            window.umami.track(event, meta);
+        } else {
+            window.umami.track(event);
+        }
+    } catch  {}
+}
+export function trackRevenue(args) {
+    const meta = {
+        revenue: args.value,
+        currency: args.currency
+    };
+    if (args.plan) meta.plan = args.plan;
+    if (args.transactionId) meta.transaction_id = args.transactionId;
+    track(args.event, meta);
+}
+export function setProfileId(id) {
+    if (!active || typeof window === "undefined" || !window.umami?.identify) return;
+    try {
+        window.umami.identify(id ? {
+            profileId: id
+        } : {});
+    } catch  {}
+}
+function injectScript(umami) {
+    if (typeof document === "undefined") return;
+    if (!(umami.autoInjectScript ?? true)) return;
+    if (document.querySelector(`script[data-website-id="${umami.websiteId}"]`)) return;
+    const script = document.createElement("script");
+    script.defer = true;
+    script.src = `${umami.host.replace(/\/+$/, "")}/script.js`;
+    script.dataset.websiteId = umami.websiteId;
+    if (umami.performance) script.dataset.performance = "true";
+    if (umami.tag) script.dataset.tag = umami.tag;
+    if (umami.beforeSend) script.dataset.beforeSend = umami.beforeSend;
+    if (umami.domains?.length) script.dataset.domains = umami.domains.join(",");
+    if (umami.doNotTrack) script.dataset.doNotTrack = "true";
+    if (umami.autoTrack === false) script.dataset.autoTrack = "false";
+    if (umami.excludeSearch) script.dataset.excludeSearch = "true";
+    if (umami.excludeHash) script.dataset.excludeHash = "true";
+    document.head.appendChild(script);
+}