blume 2.0.1 → 2.0.3

package/src/ai/tar.ts

@@ -22,42 +22,169 @@ export interface TarEntry {
   path: string;
 }
 
-/** ustar `name` field capacity; skill layouts are shallow, so no `prefix`. */
+/** ustar `name` field capacity. */
 const NAME_MAX = 100;
+/** ustar `prefix` field capacity; `prefix/name` reaches 255 bytes. */
+const PREFIX_MAX = 155;
+
+/** ustar header byte offsets nanotar leaves for us to patch. */
+const CHECKSUM_OFFSET = 148;
+const CHECKSUM_SIZE = 8;
+const TYPEFLAG_OFFSET = 156;
+const PREFIX_OFFSET = 345;
+const BLOCK_SIZE = 512;
+
+/** The two zero blocks that mark the end of an archive. */
+const END_OF_ARCHIVE = 2 * BLOCK_SIZE;
+/** tar's default record size (20 blocks), which the archive is padded to. */
+const RECORD_SIZE = 20 * BLOCK_SIZE;
+
+/** The PAX extended-header typeflag (`x`). */
+const PAX_TYPEFLAG = 0x78;
 
 const encoder = new TextEncoder();
 
+const byteLength = (value: string): number => encoder.encode(value).byteLength;
+
+/** `value` cut to at most `max` UTF-8 bytes, on a character boundary. */
+const truncateBytes = (value: string, max: number): string =>
+  value.slice(0, encoder.encodeInto(value, new Uint8Array(max)).read);
+
+/** One header nanotar writes, plus the fields it cannot. */
+interface Block {
+  content: Uint8Array;
+  mode: string;
+  name: string;
+  /** The PAX extended header ahead of an over-long path. */
+  pax?: boolean;
+  /** ustar `prefix`, joined to `name` with a `/` by readers. */
+  prefix?: string;
+}
+
+/**
+ * Split a path over the `name` field at a `/` so the head fits `prefix` and
+ * the tail fits `name`. The longest head that fits leaves the shortest tail,
+ * so if that tail is still too long no split works.
+ */
+const splitUstar = (
+  path: string
+): { name: string; prefix: string } | undefined => {
+  let slash = path.lastIndexOf("/");
+  while (slash > 0 && byteLength(path.slice(0, slash)) > PREFIX_MAX) {
+    slash = path.lastIndexOf("/", slash - 1);
+  }
+  const name = path.slice(slash + 1);
+  if (slash <= 0 || byteLength(name) > NAME_MAX) {
+    return undefined;
+  }
+  return { name, prefix: path.slice(0, slash) };
+};
+
+/**
+ * A PAX `path` record: `"<length> path=<value>\n"`, where the decimal length
+ * counts the whole record including its own digits.
+ */
+const paxPathRecord = (path: string): Uint8Array => {
+  const body = ` path=${path}\n`;
+  const size = byteLength(body);
+  const length = size + String(size + String(size).length).length;
+  return encoder.encode(`${length}${body}`);
+};
+
+/**
+ * The header blocks for one entry. A path that fits `name` is written as is;
+ * up to 255 bytes it splits across `prefix` and `name`; beyond that (or with
+ * no usable split) a PAX extended header carries the full path and the ustar
+ * `name` holds a truncated fallback for readers that ignore PAX.
+ */
+const entryBlocks = (entry: TarEntry): Block[] => {
+  const mode = entry.executable ? "755" : "644";
+  const file = { content: entry.content, mode };
+  if (byteLength(entry.path) <= NAME_MAX) {
+    return [{ ...file, name: entry.path }];
+  }
+  const split = splitUstar(entry.path);
+  if (split) {
+    return [{ ...file, ...split }];
+  }
+  const base = entry.path.slice(entry.path.lastIndexOf("/") + 1);
+  return [
+    {
+      content: paxPathRecord(entry.path),
+      mode: "644",
+      name: truncateBytes(`PaxHeader/${base}`, NAME_MAX),
+      pax: true,
+    },
+    { ...file, name: truncateBytes(base, NAME_MAX) },
+  ];
+};
+
+/** Recompute a patched header's checksum (nanotar's octal format). */
+const writeChecksum = (header: Uint8Array): void => {
+  header.fill(0x20, CHECKSUM_OFFSET, CHECKSUM_OFFSET + CHECKSUM_SIZE);
+  const sum = header.reduce((total, byte) => total + byte, 0);
+  header.fill(0, CHECKSUM_OFFSET, CHECKSUM_OFFSET + CHECKSUM_SIZE);
+  encoder.encodeInto(
+    sum.toString(8),
+    header.subarray(CHECKSUM_OFFSET, CHECKSUM_OFFSET + CHECKSUM_SIZE)
+  );
+};
+
 /**
  * Build a gzipped ustar archive of the given files, in the given order. Paths
- * longer than the ustar `name` field or escaping the archive root throw to
- * surface a programming error — nanotar would silently truncate an oversized
- * name into a corrupt archive, so the validation stays here.
+ * escaping the archive root throw to surface a programming error.
  */
 export const buildTarGz = (entries: readonly TarEntry[]): Uint8Array => {
   for (const entry of entries) {
-    if (encoder.encode(entry.path).byteLength > NAME_MAX) {
-      throw new Error(`tar path exceeds ${NAME_MAX} bytes: ${entry.path}`);
-    }
     if (entry.path.startsWith("/") || entry.path.split("/").includes("..")) {
       throw new Error(`tar path must be archive-relative: ${entry.path}`);
     }
   }
+  const blocks = entries.flatMap(entryBlocks);
   const tar = createTar(
-    entries.map((entry) => ({
+    blocks.map((block) => ({
       // Root-owned, epoch-mtime, empty owner names: every field a rebuild
       // could vary is pinned so the archive bytes are a function of content.
       attrs: {
         gid: 0,
         group: "",
-        mode: entry.executable ? "755" : "644",
+        mode: block.mode,
         mtime: 0,
         uid: 0,
         user: "",
       },
-      data: entry.content,
-      name: entry.path,
+      data: block.content,
+      name: block.name,
     }))
   );
+  // nanotar writes neither `prefix` nor the PAX typeflag, so patch those
+  // headers in place and re-sum them.
+  let offset = 0;
+  for (const block of blocks) {
+    const header = tar.subarray(offset, offset + BLOCK_SIZE);
+    if (block.prefix) {
+      encoder.encodeInto(
+        block.prefix,
+        header.subarray(PREFIX_OFFSET, PREFIX_OFFSET + PREFIX_MAX)
+      );
+      writeChecksum(header);
+    }
+    if (block.pax) {
+      header[TYPEFLAG_OFFSET] = PAX_TYPEFLAG;
+      writeChecksum(header);
+    }
+    offset +=
+      BLOCK_SIZE * (1 + Math.ceil(block.content.byteLength / BLOCK_SIZE));
+  }
+  // nanotar pads the entries to a whole record but writes no end-of-archive
+  // marker, so entries ending within two blocks of a record boundary leave
+  // fewer than the two zero blocks readers expect (GNU tar warns "A lone zero
+  // block"). Pad to the first record that fits both; for every other archive
+  // that is the size nanotar already wrote, so its bytes are unchanged.
+  const archive = new Uint8Array(
+    Math.ceil((offset + END_OF_ARCHIVE) / RECORD_SIZE) * RECORD_SIZE
+  );
+  archive.set(tar.subarray(0, offset));
   // Sync gzip with a pinned level; Node writes no timestamp into the header.
-  return new Uint8Array(gzipSync(tar, { level: 9 }));
+  return new Uint8Array(gzipSync(archive, { level: 9 }));
 };

package/src/ai/visibility.ts

@@ -1,10 +1,44 @@
-// Mirrors the fence masking in `core/sources/assets.ts`: a fenced code sample
-// that *shows* `<Visibility>` markup must keep showing what the author wrote.
-const CODE_FENCE_BLOCK =
-  /^(?<fence>`{3,}|~{3,})[^\n]*\n[\s\S]*?^\k<fence>[^\n]*(?=\n|$)/gmu;
+import { nextFenceState } from "../core/code-fences.ts";
+import type { FenceState } from "../core/code-fences.ts";
+
+/** An inline code span on one line, as the other source scanners read it. */
+const INLINE_CODE = /`[^`\n]*`/gu;
 // NUL delimiters cannot appear in authored markdown, so tokens never collide.
 // oxlint-disable-next-line no-control-regex -- the NUL is the collision guard.
-const FENCE_TOKEN = /\u0000blume-fence-(?<index>\d+)\u0000/gu;
+const CODE_TOKEN = /\u0000blume-code-(?<index>\d+)\u0000/gu;
+
+/**
+ * Swap every code sample for a one-line token — fenced blocks at any indent
+ * (a fence inside a `<Tab>` or `<Step>` is indented under it) and inline code
+ * spans — so markup that *shows* `<Visibility>` keeps showing what the author
+ * wrote. An unclosed fence runs to the end, as CommonMark reads it.
+ */
+const maskCode = (markdown: string, stash: string[]): string => {
+  const token = (code: string): string => {
+    stash.push(code);
+    return `\u0000blume-code-${stash.length - 1}\u0000`;
+  };
+  const lines: string[] = [];
+  let fence: FenceState = null;
+  let block: string[] = [];
+  for (const line of markdown.split("\n")) {
+    const next = nextFenceState(line, fence);
+    if (fence === null && next === null) {
+      lines.push(line.replaceAll(INLINE_CODE, token));
+    } else {
+      block.push(line);
+      if (next === null) {
+        lines.push(token(block.join("\n")));
+        block = [];
+      }
+    }
+    fence = next;
+  }
+  if (block.length > 0) {
+    lines.push(token(block.join("\n")));
+  }
+  return lines.join("\n");
+};
 
 /** The audience an output surface serves — the component's two `for` values. */
 export type VisibilityAudience = "agents" | "web";
@@ -36,12 +70,9 @@ export const applyAudienceVisibility = (
   markdown: string,
   audience: VisibilityAudience
 ): string => {
-  // Mask fenced code blocks so documentation *about* Visibility survives.
-  const fences: string[] = [];
-  const masked = markdown.replace(CODE_FENCE_BLOCK, (block) => {
-    fences.push(block);
-    return `\u0000blume-fence-${fences.length - 1}\u0000`;
-  });
+  // Mask code so documentation *about* Visibility survives.
+  const code: string[] = [];
+  const masked = maskCode(markdown, code);
 
   let touched = false;
   const filtered = masked
@@ -56,12 +87,12 @@ export const applyAudienceVisibility = (
 
   // Removing/unwrapping block-level tags leaves runs of blank lines behind;
   // collapse them only when something matched so untouched files round-trip
-  // exactly. Fences are masked as single-line tokens, so they are unaffected.
+  // exactly. Code is masked as single-line tokens, so it is unaffected.
   const tidied = touched ? filtered.replaceAll(/\n{3,}/gu, "\n\n") : filtered;
 
   return tidied.replaceAll(
-    FENCE_TOKEN,
-    (token, index) => fences[Number(index)] ?? token
+    CODE_TOKEN,
+    (token, index) => code[Number(index)] ?? token
   );
 };
 

package/src/analytics/databuddy.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import { adapterDescriptorSchema } from "../core/adapter.ts";
+import type { HeadScript } from "./head.ts";
+
+/** The script Databuddy's install snippet loads. */
+export const DATABUDDY_SCRIPT_SRC = "https://cdn.databuddy.cc/databuddy.js";
+
+/** The options {@link databuddy} maps itself. */
+export interface DatabuddyNamedOptions {
+  /** Client ID, from the website's settings in the Databuddy dashboard. */
+  clientId: string;
+}
+
+/**
+ * Options for {@link databuddy}: the client ID plus any other tracker setting,
+ * forwarded as a `data-` attribute on the tag (`"track-web-vitals"` →
+ * `data-track-web-vitals`, `"track-errors"`, `"track-outgoing-links"`,
+ * `"api-url"`, …).
+ */
+export type DatabuddyOptions = DatabuddyNamedOptions & {
+  [setting: string]: string;
+};
+
+export const databuddyOptionsSchema = z
+  .object({
+    clientId: z.string().min(1),
+  })
+  .catchall(z.string());
+
+export type DatabuddyAdapter = AdapterDescriptor<"databuddy", DatabuddyOptions>;
+
+export const databuddyAdapterSchema = adapterDescriptorSchema(
+  "databuddy",
+  databuddyOptionsSchema
+);
+
+/**
+ * Databuddy. The client ID is public — it's in the tag on every page.
+ */
+export const databuddy = (options: DatabuddyOptions): DatabuddyAdapter => ({
+  kind: "databuddy",
+  options,
+  requiredSecrets: [],
+  runtimeDeps: [],
+});
+
+/**
+ * The async tag from the install instructions, with `clientId` as
+ * `data-client-id` and every other option as its own `data-` attribute. The
+ * tracker skips setup when `window.databuddy` already exists, so there is no
+ * queue stub. Databuddy's script tracks history changes on its own, so
+ * client-router navigations need no extra hook.
+ */
+export const databuddyHead = (options: DatabuddyOptions): HeadScript[] => {
+  const { clientId, ...settings } = options;
+  const attributes: HeadScript["attributes"] = {};
+  for (const [setting, value] of Object.entries(settings)) {
+    attributes[`data-${setting}`] = value;
+  }
+  attributes["data-client-id"] = clientId;
+  attributes.async = true;
+  attributes.crossorigin = "anonymous";
+  attributes.src = DATABUDDY_SCRIPT_SRC;
+  return [{ attributes, content: null }];
+};

package/src/analytics/head.ts

@@ -3,6 +3,7 @@ import { amplitudeHead } from "./amplitude.ts";
 import { clarityHead } from "./clarity.ts";
 import { clearbitHead } from "./clearbit.ts";
 import { cloudflareHead } from "./cloudflare.ts";
+import { databuddyHead } from "./databuddy.ts";
 import { fathomHead } from "./fathom.ts";
 import { googleAnalyticsHead } from "./google-analytics.ts";
 import { googleTagManagerHead } from "./google-tag-manager.ts";
@@ -11,6 +12,7 @@ import { hightouchHead } from "./hightouch.ts";
 import { hotjarHead } from "./hotjar.ts";
 import { logrocketHead } from "./logrocket.ts";
 import { mixpanelHead } from "./mixpanel.ts";
+import { oneDollarStatsHead } from "./one-dollar-stats.ts";
 import { pirschHead } from "./pirsch.ts";
 import { plausibleHead } from "./plausible.ts";
 import { posthogHead } from "./posthog.ts";
@@ -64,6 +66,9 @@ const adapterScripts = (
     case "cloudflare": {
       return cloudflareHead(adapter.options);
     }
+    case "databuddy": {
+      return databuddyHead(adapter.options);
+    }
     case "fathom": {
       return fathomHead(adapter.options);
     }
@@ -88,6 +93,9 @@ const adapterScripts = (
     case "mixpanel": {
       return mixpanelHead(adapter.options);
     }
+    case "one-dollar-stats": {
+      return oneDollarStatsHead(adapter.options);
+    }
     case "pirsch": {
       return pirschHead(adapter.options);
     }

package/src/analytics/index.ts

@@ -30,6 +30,8 @@ export { clearbit } from "./clearbit.ts";
 export type { ClearbitAdapter, ClearbitOptions } from "./clearbit.ts";
 export { cloudflare } from "./cloudflare.ts";
 export type { CloudflareAdapter, CloudflareOptions } from "./cloudflare.ts";
+export { databuddy } from "./databuddy.ts";
+export type { DatabuddyAdapter, DatabuddyOptions } from "./databuddy.ts";
 export { fathom } from "./fathom.ts";
 export type { FathomAdapter, FathomOptions } from "./fathom.ts";
 export { googleAnalytics } from "./google-analytics.ts";
@@ -56,6 +58,11 @@ export type {
   MixpanelOptions,
   MixpanelRegion,
 } from "./mixpanel.ts";
+export { oneDollarStats } from "./one-dollar-stats.ts";
+export type {
+  OneDollarStatsAdapter,
+  OneDollarStatsOptions,
+} from "./one-dollar-stats.ts";
 export { pirsch } from "./pirsch.ts";
 export type { PirschAdapter, PirschOptions } from "./pirsch.ts";
 export { plausible } from "./plausible.ts";

package/src/analytics/one-dollar-stats.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import { adapterDescriptorSchema } from "../core/adapter.ts";
+import type { HeadScript } from "./head.ts";
+
+/** The script OneDollarStats' install snippet loads. */
+export const ONE_DOLLAR_STATS_SCRIPT_SRC =
+  "https://assets.onedollarstats.com/stonks.js";
+
+/** The options {@link oneDollarStats} checks itself. */
+export interface OneDollarStatsNamedOptions {
+  /**
+   * A bare host name, e.g. `docs.example.com`. The tracker reports every
+   * event under it on every host, not just `localhost`.
+   */
+  hostname?: string;
+}
+
+/**
+ * Options for {@link oneDollarStats}: any tracker setting, forwarded as a
+ * `data-` attribute on the tag (`hostname` → `data-hostname`, `devmode`,
+ * `url`, `autocollect`, `"hash-routing"`, …).
+ */
+export type OneDollarStatsOptions = OneDollarStatsNamedOptions & {
+  [setting: string]: string;
+};
+
+export const oneDollarStatsOptionsSchema = z
+  .object({
+    hostname: z
+      .string()
+      .regex(/^[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)*(?::\d+)?$/u, {
+        message:
+          "`hostname` must be a bare host name like `docs.example.com`, without `https://`, a path, a query, or a fragment.",
+      })
+      .optional(),
+  })
+  .catchall(z.string());
+
+export type OneDollarStatsAdapter = AdapterDescriptor<
+  "one-dollar-stats",
+  OneDollarStatsOptions
+>;
+
+export const oneDollarStatsAdapterSchema = adapterDescriptorSchema(
+  "one-dollar-stats",
+  oneDollarStatsOptionsSchema
+);
+
+/**
+ * OneDollarStats. Needs no keys — the dashboard matches events to a site by
+ * the domain they come from.
+ */
+export const oneDollarStats = (
+  options: OneDollarStatsOptions = {}
+): OneDollarStatsAdapter => ({
+  kind: "one-dollar-stats",
+  options,
+  requiredSecrets: [],
+  runtimeDeps: [],
+});
+
+/**
+ * The deferred tag from the install instructions, with every option as its
+ * own `data-` attribute. The tracker reads them from `document.currentScript`,
+ * so the tag stays a classic external script. It hooks `pushState` and
+ * `popstate` itself, so client-router navigations need no extra hook.
+ *
+ * The tracker turns hash routing on whenever `data-hash-routing` is present,
+ * whatever its value, so `"hash-routing": "false"` leaves the attribute off.
+ */
+export const oneDollarStatsHead = (
+  options: OneDollarStatsOptions
+): HeadScript[] => {
+  const attributes: HeadScript["attributes"] = {};
+  for (const [setting, value] of Object.entries(options)) {
+    if (setting === "hash-routing" && value === "false") {
+      continue;
+    }
+    attributes[`data-${setting}`] = value;
+  }
+  attributes.defer = true;
+  attributes.src = ONE_DOLLAR_STATS_SCRIPT_SRC;
+  return [{ attributes, content: null }];
+};

package/src/analytics/posthog.ts

@@ -54,13 +54,30 @@ export const posthog = (options: PosthogOptions): PosthogAdapter => ({
 const POSTHOG_LOADER =
   '!function(t,e){var o,n,p,r;e.__SV||(window.posthog=e,e._i=[],e.init=function(i,s,a){function g(t,e){var o=e.split(".");2==o.length&&(t=t[o[0]],e=o[1]),t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}}(p=t.createElement("script")).type="text/javascript",p.crossOrigin="anonymous",p.async=!0,p.src=s.api_host.replace(".i.posthog.com","-assets.i.posthog.com")+"/static/array.js",(r=t.getElementsByTagName("script")[0]).parentNode.insertBefore(p,r);var u=e;for(void 0!==a?u=e[a]=[]:a="posthog",u.people=u.people||[],u.toString=function(t){var e="posthog";return"posthog"!==a&&(e+="."+a),t||(e+=" (stub)"),e},u.people.toString=function(){return u.toString(1)+".people (stub)"},o="init capture register register_once register_for_session unregister unregister_for_session getFeatureFlag getFeatureFlagPayload isFeatureEnabled reloadFeatureFlags updateEarlyAccessFeatureEnrollment getEarlyAccessFeatures on onFeatureFlags onSessionId getSurveys getActiveMatchingSurveys renderSurvey canRenderSurvey getNextSurveyStep identify setPersonProperties group resetGroups setPersonPropertiesForFlags resetPersonPropertiesForFlags setGroupPropertiesForFlags resetGroupPropertiesForFlags reset get_distinct_id getGroups get_session_id get_session_replay_url alias set_config startSessionRecording stopSessionRecording sessionRecordingStarted captureException loadToolbar get_property getSessionProperty createPersonProfile opt_in_capturing opt_out_capturing has_opted_in_capturing has_opted_out_capturing clear_opt_in_out_capturing debug getPageViewId captureTraceFeedback captureTraceMetric".split(" "),n=0;n<o.length;n++)g(u,o[n]);e._i.push([i,s,a])},e.__SV=1)}(document,window.posthog||[]);';
 
-// PostHog's loader only captures a pageview per real page load, so the client
-// router's in-place swaps are captured here.
+// With PostHog's classic pageview setting its loader captures one pageview
+// per real page load, so the client router's in-place swaps are captured here.
 const POSTHOG_SPA_PAGEVIEWS = spaPageviews(
   "__blumePosthogPath",
   'posthog.capture("$pageview");'
 );
 
+/**
+ * Whether Blume should capture client-router navigations itself, given the
+ * `posthog.init` options. Only when PostHog captures load-time pageviews and
+ * nothing more: `capture_pageview: false` turns pageviews off, and
+ * `capture_pageview: "history_change"` — the default under any `defaults`
+ * snapshot (`defaults: "2025-05-24"` in PostHog's current snippet), unless
+ * `capture_pageview` says otherwise — already captures every navigation, so
+ * sending another would count each one twice.
+ */
+const capturesNavigations = (init: Record<string, JsonValue>): boolean => {
+  const setting = init.capture_pageview;
+  if (setting === undefined) {
+    return init.defaults === undefined || init.defaults === "unset";
+  }
+  return setting !== false && setting !== "history_change";
+};
+
 /**
  * The inline loader-plus-init snippet. `key` and `host` are the options Blume
  * maps (`host` becomes `api_host`); everything else lands in `posthog.init`'s
@@ -69,10 +86,11 @@ const POSTHOG_SPA_PAGEVIEWS = spaPageviews(
 export const posthogHead = (options: PosthogOptions): HeadScript[] => {
   const { host, key, ...init } = options;
   const initOptions = { api_host: host ?? POSTHOG_DEFAULT_HOST, ...init };
+  const pageviews = capturesNavigations(init) ? POSTHOG_SPA_PAGEVIEWS : "";
   return [
     {
       attributes: {},
-      content: `${POSTHOG_LOADER}posthog.init(${inlineJson(key)},${inlineJson(initOptions)});${POSTHOG_SPA_PAGEVIEWS}`,
+      content: `${POSTHOG_LOADER}posthog.init(${inlineJson(key)},${inlineJson(initOptions)});${pageviews}`,
     },
   ];
 };

package/src/analytics/schema.ts

@@ -5,6 +5,7 @@ import { amplitudeAdapterSchema } from "./amplitude.ts";
 import { clarityAdapterSchema } from "./clarity.ts";
 import { clearbitAdapterSchema } from "./clearbit.ts";
 import { cloudflareAdapterSchema } from "./cloudflare.ts";
+import { databuddyAdapterSchema } from "./databuddy.ts";
 import { fathomAdapterSchema } from "./fathom.ts";
 import { googleAnalyticsAdapterSchema } from "./google-analytics.ts";
 import { googleTagManagerAdapterSchema } from "./google-tag-manager.ts";
@@ -13,6 +14,7 @@ import { hightouchAdapterSchema } from "./hightouch.ts";
 import { hotjarAdapterSchema } from "./hotjar.ts";
 import { logrocketAdapterSchema } from "./logrocket.ts";
 import { mixpanelAdapterSchema } from "./mixpanel.ts";
+import { oneDollarStatsAdapterSchema } from "./one-dollar-stats.ts";
 import { pirschAdapterSchema } from "./pirsch.ts";
 import { plausibleAdapterSchema } from "./plausible.ts";
 import { posthogAdapterSchema } from "./posthog.ts";
@@ -27,6 +29,7 @@ export const analyticsAdapterSchema = z.discriminatedUnion("kind", [
   clarityAdapterSchema,
   clearbitAdapterSchema,
   cloudflareAdapterSchema,
+  databuddyAdapterSchema,
   fathomAdapterSchema,
   googleAnalyticsAdapterSchema,
   googleTagManagerAdapterSchema,
@@ -35,6 +38,7 @@ export const analyticsAdapterSchema = z.discriminatedUnion("kind", [
   hotjarAdapterSchema,
   logrocketAdapterSchema,
   mixpanelAdapterSchema,
+  oneDollarStatsAdapterSchema,
   pirschAdapterSchema,
   plausibleAdapterSchema,
   posthogAdapterSchema,