@wix/agent-skills 1.0.0

package/skills/wix-headless/scripts/patch-decorative-slots.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+// Inject Image-Phase-1 decorative URLs into the designer-emitted page shells.
+//
+// The Phase 2 designer writes `<div data-decorative-slot="<key>">…</div>`
+// placeholders in src/pages/*.astro. Image Phase 1 writes resolved URLs to
+// .wix/image-urls.md. This script reads both, then injects an <img> element
+// as the first child of each matching slot div — pure string substitution,
+// no LLM, no file rewrites.
+//
+// Usage:
+//   node patch-decorative-slots.mjs <project-dir>
+//
+// Behavior:
+//   - If .wix/image-urls.md doesn't exist, exit 0 silently (Image Phase 1
+//     timed out / failed; the slot placeholders look complete on their own).
+//   - For each `data-decorative-slot="<key>"` in src/pages/*.astro:
+//       * If <key> has no URL in image-urls.md → leave the div alone.
+//       * If the div is self-closing or already has a child element other
+//         than whitespace/comments → skip with a warning (don't clobber).
+//       * Otherwise inject <img …> as the first child.
+//   - Output a JSON summary of patches/skips/warnings to stdout.
+//   - Exit 0 even when some slots couldn't be patched — placeholders fall
+//     back to the designer's aspect-ratio + background-color rendering.
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+const projectDir = process.argv[2] ?? process.cwd();
+
+const imageUrlsPath = join(projectDir, ".wix/image-urls.md");
+if (!existsSync(imageUrlsPath)) {
+  console.log(JSON.stringify({ status: "skipped", reason: "no .wix/image-urls.md (Image Phase 1 didn't write — failed or timed out)" }));
+  process.exit(0);
+}
+
+// Parse `## <key>\n- url: <url>` blocks from .wix/image-urls.md.
+const imageUrlsRaw = readFileSync(imageUrlsPath, "utf8");
+const urlMap = {};
+// Match `## key\n…- url: <url>` per section. The inner `(?:(?!^##\s)[\s\S])*?`
+// forbids the lazy span from crossing into the next `## ` line — without
+// that guard, an empty `- url:` for one slot silently steals the next
+// section's URL on partial-failure runs.
+const sectionRegex = /^##\s+(\S+)\s*\n(?:(?!^##\s)[\s\S])*?-\s*url:\s*(https?:\/\/\S+)/gm;
+let m;
+while ((m = sectionRegex.exec(imageUrlsRaw)) !== null) {
+  urlMap[m[1]] = m[2];
+}
+
+if (Object.keys(urlMap).length === 0) {
+  console.log(JSON.stringify({ status: "skipped", reason: ".wix/image-urls.md exists but has no parseable `## key` + `- url:` blocks" }));
+  process.exit(0);
+}
+
+// Find candidate page files: src/pages/*.astro, recursively (designer may emit
+// /about.astro at top level OR /pages/about.astro).
+const pagesDir = join(projectDir, "src/pages");
+const candidates = [];
+const walk = (dir) => {
+  if (!existsSync(dir)) return;
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const stat = statSync(full);
+    if (stat.isDirectory()) walk(full);
+    else if (stat.isFile() && entry.endsWith(".astro")) candidates.push(full);
+  }
+};
+walk(pagesDir);
+
+const patched = [];
+const skipped = [];
+const warnings = [];
+
+const SLOT_DIV_REGEX = /(<div[^>]*\bdata-decorative-slot="([^"]+)"[^>]*>)([\s\S]*?)(<\/div>)/g;
+
+for (const file of candidates) {
+  const original = readFileSync(file, "utf8");
+  let modified = original;
+  let fileChanged = false;
+
+  modified = modified.replace(SLOT_DIV_REGEX, (match, openTag, slotKey, inner, closeTag) => {
+    const url = urlMap[slotKey];
+    if (!url) {
+      skipped.push({ file, slot: slotKey, reason: "no URL for this slot in image-urls.md" });
+      return match;
+    }
+
+    // Strip HTML comments before any content checks — the designer's placeholder
+    // is a comment like `<!-- orchestrator injects <img> here -->`, which would
+    // otherwise false-positive both the idempotency and clobber-guard checks.
+    const stripped = inner.replace(/<!--[\s\S]*?-->/g, "").trim();
+
+    // Skip if div already contains an <img> element (idempotency).
+    if (/<img\b/i.test(stripped)) {
+      skipped.push({ file, slot: slotKey, reason: "div already contains an <img> tag (idempotent skip)" });
+      return match;
+    }
+
+    // Skip if div has substantive child content beyond whitespace/comments.
+    if (stripped.length > 0) {
+      warnings.push({ file, slot: slotKey, reason: "div has existing non-image child content; not patching to avoid clobber" });
+      return match;
+    }
+
+    fileChanged = true;
+    const img = `<img src="${url}" alt="" loading="lazy" decoding="async" class="decorative-slot-img" />`;
+    patched.push({ file, slot: slotKey });
+    // Preserve any whitespace inside the div (e.g., the newline + indent).
+    return `${openTag}\n      ${img}${inner}${closeTag}`;
+  });
+
+  if (fileChanged) {
+    writeFileSync(file, modified);
+  }
+}
+
+const summary = {
+  status: warnings.length > 0 ? "partial" : "ok",
+  imageUrls: Object.keys(urlMap),
+  filesScanned: candidates.length,
+  patched,
+  skipped,
+  warnings,
+};
+console.log(JSON.stringify(summary, null, 2));

package/skills/wix-headless/scripts/plan-entity-image-waves.mjs

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+// Build a deterministic execution plan for Image Phase 2 from a slim image
+// agent's prompt array + the orchestrator's per-product / per-cms-item GETs.
+//
+// The slim image agent's only job is to return a list of brand-aligned prompts
+// (one per entity). This script transforms that list (plus the entity details
+// the orchestrator pre-fetched) into a structured plan the orchestrator can
+// execute as a sequence of concurrent batches:
+//
+//   waves     — Runware generation requests, grouped into waves of <waveSize>
+//               (default 3) to match the google:4@2 throttle. Each wave is
+//               one orchestration step with N parallel CallWixSiteAPI tool
+//               calls; each tool call sends one task in the body array.
+//
+//   imports   — POST /site-media/v1/files/import requests, one per generated
+//               image. Indexed by taskUUID so the orchestrator threads the
+//               wave-result URL through to the import body.
+//
+//   patches   — Per-entity-type write requests (PATCH for products & blog
+//               posts; PUT for CMS items). Bodies use placeholders the
+//               orchestrator substitutes with import results:
+//                 __IMAGE_URL__       — the full wixstatic URL (file.url)
+//                 __IMAGE_FILE_ID__   — the file ID (file.fileUrl)
+//
+//   publishes — Re-publish calls for blog posts ONLY (PATCHing a published
+//               draft un-publishes it). One per blog-post entity.
+//
+// Usage:
+//   echo "$INPUT_JSON" | node plan-entity-image-waves.mjs
+//
+// The script is pure data transformation — no I/O beyond stdin / stdout, no
+// MCP, no network. The encoded knowledge is the per-entity-type body shapes
+// (frozen from references/images/INSTRUCTIONS.md so a single source of truth).
+
+import { readFileSync } from "node:fs";
+
+// Body shape constants — keep aligned with references/images/INSTRUCTIONS.md.
+const RUNWARE_DEFAULTS = {
+  taskType: "imageInference",
+  outputType: "URL",
+  outputFormat: "PNG",
+  model: "google:4@2",
+  numberResults: 1,
+};
+
+const DEFAULT_WAVE_SIZE = 3;
+
+let input;
+try {
+  input = JSON.parse(readFileSync(0, "utf8"));
+} catch (e) {
+  console.error(`plan-entity-image-waves: stdin is not valid JSON (${e.message})`);
+  process.exit(2);
+}
+
+const prompts = Array.isArray(input.prompts) ? input.prompts : [];
+if (prompts.length === 0) {
+  console.error("plan-entity-image-waves: no prompts in input — nothing to plan");
+  process.exit(2);
+}
+
+const productDetails = input.productDetails ?? {};
+const cmsDetails = input.cmsDetails ?? {};
+const waveSize = Math.max(1, Math.min(input.waveSize ?? DEFAULT_WAVE_SIZE, 8));
+const model = input.model ?? RUNWARE_DEFAULTS.model;
+
+// ---- 1. Runware waves (gen-side parallelism, throttle-bucketed) -----------
+const waves = [];
+for (let i = 0; i < prompts.length; i += waveSize) {
+  const slice = prompts.slice(i, i + waveSize);
+  waves.push(slice.map((p) => ({
+    taskUUID: p.taskUUID,
+    body: [{
+      ...RUNWARE_DEFAULTS,
+      model,
+      taskUUID: p.taskUUID,
+      positivePrompt: p.positivePrompt,
+      width: p.width ?? 1024,
+      height: p.height ?? 1024,
+      outputFormat: p.outputFormat ?? RUNWARE_DEFAULTS.outputFormat,
+    }],
+  })));
+}
+
+// ---- 2. Wix Media imports (one per generated image) -----------------------
+const imports = prompts.map((p) => ({
+  taskUUID: p.taskUUID,
+  mimeType: p.outputFormat === "JPG" ? "image/jpeg" : "image/png",
+  displayName: p.displayName ?? `${p.entityId}.${(p.outputFormat ?? "PNG").toLowerCase()}`,
+}));
+
+// ---- 3. Per-entity-type write requests ------------------------------------
+const patches = [];
+const publishes = [];
+
+for (const p of prompts) {
+  if (p.entityType === "product") {
+    const detail = productDetails[p.entityId];
+    if (!detail) {
+      console.error(`plan-entity-image-waves: missing productDetails for entityId=${p.entityId}`);
+      process.exit(1);
+    }
+    if (detail.revision === undefined || detail.revision === null) {
+      console.error(`plan-entity-image-waves: productDetails[${p.entityId}].revision is required (mandatory per Update-Product endpoint)`);
+      process.exit(1);
+    }
+    patches.push({
+      taskUUID: p.taskUUID,
+      entityType: "product",
+      entityId: p.entityId,
+      method: "PATCH",
+      url: `https://www.wixapis.com/stores/v3/products/${p.entityId}`,
+      // Body echoes options + variantsInfo (mandatory — see images/INSTRUCTIONS.md
+      // §428-prevention) and embeds the URL via __IMAGE_URL__ placeholder.
+      body: {
+        product: {
+          revision: detail.revision,
+          media: {
+            itemsInfo: {
+              items: [{ url: "__IMAGE_URL__", altText: p.displayName ?? p.entityId }],
+            },
+          },
+          ...(detail.options !== undefined ? { options: detail.options } : {}),
+          ...(detail.variantsInfo !== undefined ? { variantsInfo: detail.variantsInfo } : {}),
+        },
+      },
+    });
+  } else if (p.entityType === "blogPost") {
+    patches.push({
+      taskUUID: p.taskUUID,
+      entityType: "blogPost",
+      entityId: p.entityId,
+      method: "PATCH",
+      url: `https://www.wixapis.com/blog/v3/draft-posts/${p.entityId}`,
+      // Blog uses the file ID (fileUrl), not the wixstatic URL.
+      body: {
+        draftPost: {
+          media: { wixMedia: { image: { id: "__IMAGE_FILE_ID__" } } },
+        },
+      },
+    });
+    publishes.push({
+      entityId: p.entityId,
+      method: "POST",
+      url: `https://www.wixapis.com/blog/v3/draft-posts/${p.entityId}/publish`,
+    });
+  } else if (p.entityType === "cmsItem") {
+    const detail = cmsDetails[p.entityId];
+    if (!detail) {
+      console.error(`plan-entity-image-waves: missing cmsDetails for entityId=${p.entityId}`);
+      process.exit(1);
+    }
+    if (!detail.collectionId || !detail.imageField || !detail.data) {
+      console.error(`plan-entity-image-waves: cmsDetails[${p.entityId}] requires collectionId, imageField, and data (existing item record)`);
+      process.exit(1);
+    }
+    // Read-merge-PUT: echo every existing data field, set the image field
+    // to the placeholder URL. Wipes nothing (the bug observed in 2026-04-19).
+    const mergedData = { ...detail.data, [detail.imageField]: "__IMAGE_URL__" };
+    patches.push({
+      taskUUID: p.taskUUID,
+      entityType: "cmsItem",
+      entityId: p.entityId,
+      method: "PUT",
+      url: `https://www.wixapis.com/wix-data/v2/items/${p.entityId}`,
+      body: {
+        dataCollectionId: detail.collectionId,
+        dataItem: { id: p.entityId, data: mergedData },
+      },
+    });
+  } else {
+    console.error(`plan-entity-image-waves: unknown entityType "${p.entityType}" for entityId=${p.entityId} — must be product | blogPost | cmsItem`);
+    process.exit(1);
+  }
+}
+
+const plan = {
+  meta: {
+    promptCount: prompts.length,
+    waveCount: waves.length,
+    waveSize,
+    model,
+  },
+  waves,
+  imports,
+  patches,
+  publishes,
+};
+
+console.log(JSON.stringify(plan, null, 2));

package/skills/wix-headless/scripts/preview.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Build the project and deploy a rotating preview URL.
+#
+# Usage:
+#   bash <SKILL_ROOT>/scripts/preview.sh
+#
+# Run from the project directory (CWD = <project>/). Requires wix.config.json.
+#
+# Output: stdout is the preview URL that `npx @wix/cli preview` printed; the
+# orchestrator captures it and records as outcome.previewUrl in run.json. All
+# other CLI output goes to stderr.
+#
+# `preview` does NOT populate the Frontend link in headless settings — that's
+# what `release.sh` is for. Use preview for fast iteration on a rotating URL;
+# use release for production deploy + transactional-email URL stability.
+#
+# Exit codes:
+#   0 — ok; preview URL on stdout
+#   <other> — build or preview failed; stderr surfaces the underlying error
+#             (TypeScript / Astro errors are code bugs, not endpoint drift —
+#              the orchestrator's recovery ladder doesn't retry build).
+
+set -euo pipefail
+
+# Build first; surface compile errors verbatim if it fails.
+npx @wix/cli build 1>&2
+
+# Preview captures the deployed URL on stdout. We tee its output to stderr for
+# the user-visible log AND parse the URL out for the orchestrator's stdout.
+PREVIEW_OUTPUT="$(mktemp)"
+trap 'rm -f "$PREVIEW_OUTPUT"' EXIT
+
+npx @wix/cli preview 2>&1 | tee "$PREVIEW_OUTPUT" 1>&2
+
+# Wix CLI prints `Site preview URL: <url>` (or similar) — extract the first
+# https URL from the output. If multiple are printed, the first is the canonical
+# preview URL.
+PREVIEW_URL="$(grep -oE 'https://[A-Za-z0-9.-]+\.wix-host\.com[^[:space:]]*' "$PREVIEW_OUTPUT" | head -n 1 || true)"
+
+if [[ -z "$PREVIEW_URL" ]]; then
+  echo "preview.sh: could not extract a *.wix-host.com URL from preview output" >&2
+  exit 1
+fi
+
+echo "$PREVIEW_URL"

package/skills/wix-headless/scripts/release.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Build the project and release to production. Unlike preview.sh, this populates
+# the Frontend link in dashboard → Settings → Headless Settings → Manage URLs,
+# which Wix injects into transactional emails (order confirmations, password
+# resets, member invites). Use release.sh for production deploys.
+#
+# Usage:
+#   bash <SKILL_ROOT>/scripts/release.sh
+#
+# Run from the project directory (CWD = <project>/). Requires wix.config.json.
+#
+# Output: stdout is the released URL that `npx @wix/cli release` printed
+# (extracted from the line `Site published on <url>`); the orchestrator
+# captures it as outcome.releaseUrl in run.json. All other CLI output goes
+# to stderr.
+#
+# Exit codes:
+#   0 — ok; release URL on stdout
+#   <other> — build or release failed; stderr surfaces the underlying error.
+#             Build failures are code bugs (TypeScript / Astro / missing
+#             module) — the orchestrator does NOT retry. Release auth failures
+#             surface as `Run npx @wix/cli login and retry.`
+#             Known transient release failures are retried by this script.
+
+set -euo pipefail
+
+npx @wix/cli build 1>&2
+
+RELEASE_OUTPUT="$(mktemp)"
+trap 'rm -f "$RELEASE_OUTPUT"' EXIT
+
+release_is_retryable() {
+  grep -Eiq 'ECONNRESET|ETIMEDOUT|EAI_AGAIN|STATE_MISMATCH|temporary system error|temporarily unavailable|try again shortly' "$RELEASE_OUTPUT"
+}
+
+MAX_RELEASE_ATTEMPTS="${WIX_RELEASE_ATTEMPTS:-3}"
+RELEASE_STATUS=1
+
+for ((attempt = 1; attempt <= MAX_RELEASE_ATTEMPTS; attempt++)); do
+  : >"$RELEASE_OUTPUT"
+  set +e
+  npx @wix/cli release 2>&1 | tee "$RELEASE_OUTPUT" 1>&2
+  RELEASE_STATUS=${PIPESTATUS[0]}
+  set -e
+
+  if [[ "$RELEASE_STATUS" -eq 0 ]]; then
+    break
+  fi
+
+  if [[ "$attempt" -lt "$MAX_RELEASE_ATTEMPTS" ]] && release_is_retryable; then
+    sleep_seconds=$((attempt * 5))
+    echo "release.sh: release attempt $attempt failed with a retryable Wix error; retrying in ${sleep_seconds}s" >&2
+    sleep "$sleep_seconds"
+    continue
+  fi
+
+  exit "$RELEASE_STATUS"
+done
+
+# CLI prints `Site published on <url>` — extract the URL after that marker.
+# Fall back to the first Wix-hosted URL if the marker line is not found
+# (CLI wording may vary between versions).
+RELEASE_URL="$(sed -nE 's/.*Site published on ([^[:space:]]+).*/\1/p' "$RELEASE_OUTPUT" | head -n 1 || true)"
+if [[ -z "$RELEASE_URL" ]]; then
+  RELEASE_URL="$(grep -oE 'https://[A-Za-z0-9.-]+\.wix-(site-)?host\.com[^[:space:]]*' "$RELEASE_OUTPUT" | head -n 1 || true)"
+fi
+
+if [[ -z "$RELEASE_URL" ]]; then
+  echo "release.sh: could not extract a release URL from release output" >&2
+  exit 1
+fi
+
+echo "$RELEASE_URL"

package/skills/wix-headless/scripts/scaffold.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# Scaffold a new Wix Managed Headless project with the pure-headless blank template.
+#
+# Usage:
+#   bash <SKILL_ROOT>/scripts/scaffold.sh <project-slug> "<Brand Name>"
+#
+# <project-slug>: 3-20 lowercase alphanumeric chars (no hyphens, no spaces) — the
+#                 Wix CLI rejects anything else. Becomes the project directory name.
+# <Brand Name>:   human-readable business name; quote if it contains spaces.
+#
+# After scaffold succeeds, read <project-slug>/wix.config.json to extract appId
+# (project's appId) and siteId (used for MCP calls). The orchestrator does that
+# read; this script just runs the npm create.
+#
+# Behavior:
+#   - Pre-flight validates the slug (regex ^[a-z0-9]{3,20}$).
+#   - Pre-flight requires both args.
+#   - Runs `npm create @wix/new@latest headless` with --no-publish + --skip-install
+#     so the orchestrator can deferred-install with its own package set.
+#   - Template ID is the pure-headless blank (vibe-compatible templates trigger
+#     an interactive prompt that blocks non-TTY runs).
+#
+# Exit codes:
+#   0 — ok
+#   2 — argument validation failed
+#   <other> — npm create failed; stderr surfaced to caller for orchestrator-side
+#             recovery (auth / invalid-template ladder lives in the orchestrator).
+
+set -euo pipefail
+
+if [[ $# -lt 2 || -z "${1:-}" || -z "${2:-}" ]]; then
+  echo "scaffold.sh: both args required. Got project-slug='${1:-}' brand-name='${2:-}'." >&2
+  echo "Usage: bash scaffold.sh <slug> \"<Brand Name>\" — slug first, brand quoted." >&2
+  exit 2
+fi
+
+if [[ ! "$1" =~ ^[a-z0-9]{3,20}$ ]]; then
+  echo "scaffold.sh: project-slug='$1' is not valid." >&2
+  echo "Slug must be 3-20 lowercase alphanumeric chars (no hyphens, no spaces)." >&2
+  echo "Derive from the brand: lowercase, strip non-[a-z0-9], truncate to 20." >&2
+  exit 2
+fi
+
+# Pure-headless blank template. Vibe-compatible templates show an interactive
+# vibe setup prompt that blocks non-TTY contexts — do not substitute.
+TEMPLATE_ID="blank"
+
+npm create @wix/new@latest headless -- \
+  --business-name "$2" \
+  --project-name "$1" \
+  --site-template "$TEMPLATE_ID" \
+  --no-publish \
+  --skip-install

package/skills/wix-headless/scripts/seed-utilities.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Copy the skill's shared utilities into the project's src/utils/ and strip the
+# Astro starter cruft that ships with the blank template.
+#
+# Usage (both modes work):
+#   bash <SKILL_ROOT>/scripts/seed-utilities.sh                # installed tgz
+#   bash <(curl -s https://dev.wix.com/skills/wix-headless/scripts/seed-utilities.sh)
+#
+# Run from the project directory (CWD = <project>/). The script auto-detects
+# whether shared-utilities is available on disk (tgz install) and falls back
+# to fetching from the well-known URL when streamed via process substitution
+# (BASH_SOURCE is /dev/fd/N, so the on-disk lookup naturally falls through).
+#
+# Behavior:
+#   - Copies the three shared utility files into src/utils/ — never overwrites
+#     an existing file (users can drop in their own version to override).
+#   - Removes Astro starter cruft (Welcome.astro + marketing SVGs) that ships
+#     with the blank template but is never imported by the build skill.
+#
+# Shared utilities copied:
+#   - wix-image.ts  — media URL resolver (used by stores, blog, cms)
+#   - analytics.ts  — event tracking (used by stores, ecom, blog)
+#   - ricos.ts      — Ricos JSON to HTML renderer for SSR Astro pages
+
+set -euo pipefail
+
+SKILL_URL="https://dev.wix.com/skills/wix-headless"
+UTILS=(analytics.ts ricos.ts wix-image.ts)
+
+# Mode detection: prefer on-disk skill root if the sibling dir exists, else
+# fetch over HTTP. Covers both tgz install and `bash <(curl ...)` streaming.
+SHARED_UTILS_DIR=""
+script_path="${BASH_SOURCE[0]}"
+if [[ -f "$script_path" ]]; then
+  candidate="$(dirname "$script_path")/../shared-utilities"
+  if [[ -d "$candidate" ]]; then
+    SHARED_UTILS_DIR="$(cd "$candidate" && pwd)"
+  fi
+fi
+
+mkdir -p src/utils
+
+for f in "${UTILS[@]}"; do
+  dest="src/utils/$f"
+  if [[ -e "$dest" ]]; then continue; fi
+  if [[ -n "$SHARED_UTILS_DIR" ]]; then
+    cp "$SHARED_UTILS_DIR/$f" "$dest"
+  else
+    curl -fsSL "$SKILL_URL/shared-utilities/$f" -o "$dest"
+  fi
+done
+
+# Astro starter cruft cleanup.
+rm -f src/components/Welcome.astro
+rm -f src/assets/astro.svg src/assets/wix.svg src/assets/background.svg

package/skills/wix-headless/shared-utilities/analytics.ts

@@ -0,0 +1,40 @@
+export type AnalyticsEventName =
+  | "AddToCart"
+  | "RemoveFromCart"
+  | "InitiateCheckout"
+  | "Purchase"
+  | "ArticleView"
+  | "FormSubmit"
+  | "AddProductImpression"
+  | "ViewContent"
+  | "ClickProduct"
+  | (string & {});
+
+export function trackEvent(
+  name: AnalyticsEventName,
+  payload?: Record<string, unknown>,
+): void {
+  if (typeof window === "undefined") return;
+
+  const event = { name, ...(payload ?? {}) };
+
+  const w = window as unknown as {
+    dataLayer?: unknown[];
+    wixAnalytics?: { track(event: { name: string } & Record<string, unknown>): void };
+  };
+
+  if (w.wixAnalytics?.track) {
+    w.wixAnalytics.track(event);
+    return;
+  }
+
+  if (w.dataLayer) {
+    w.dataLayer.push({ event: name, ...event });
+    return;
+  }
+
+  const meta = import.meta as unknown as { env?: { DEV?: boolean } };
+  if (meta.env?.DEV) {
+    console.debug("[analytics]", event);
+  }
+}