blume 2.0.0 → 2.0.2

package/src/ai/static-expression.ts

@@ -0,0 +1,416 @@
+import type { EvaluatedValue } from "./component-markdown.ts";
+
+/**
+ * Read an MDX attribute expression (`prop={...}`) as literal data, without
+ * running it. The agent Markdown downleveler converts components on every
+ * page it is handed — plain `.md` pages Astro never executes, and content a
+ * CMS or a release feed supplies — so an expression is parsed, never
+ * evaluated: only data a reader could see by looking at it is recovered.
+ *
+ * Accepted: string, number, boolean, `null`, and `undefined` literals; array
+ * and object literals, nested; unary minus on a number; template literals
+ * whose substitutions are themselves accepted; and `frontmatter.<path>`
+ * member access (dot steps, or bracketed string and number literals),
+ * resolved against the page's front matter the way `prop={frontmatter.status}`
+ * resolves when Astro renders the page. Comments are skipped. Anything else —
+ * a call, an operator, a spread, a shorthand property, any other name — is
+ * not static, and the caller keeps the component's JSX as written.
+ */
+
+/** The outcome of reading an expression: its value, or `ok: false`. */
+export interface StaticExpressionResult {
+  ok: boolean;
+  value: EvaluatedValue;
+}
+
+/**
+ * Stop reading: the expression isn't literal data. The throw unwinds the
+ * recursive descent to {@link readStaticExpression}, which reports it.
+ */
+const notStatic = (): never => {
+  throw new Error("not a static expression");
+};
+
+const isText = (value: EvaluatedValue): value is string =>
+  typeof value === "string";
+
+const isNumber = (value: EvaluatedValue): value is number =>
+  typeof value === "number";
+
+/** A nested map of values: an object literal or a front-matter mapping. */
+const isValueMap = (
+  value: EvaluatedValue
+): value is { [key: string]: EvaluatedValue } =>
+  typeof value === "object" &&
+  value !== null &&
+  !Array.isArray(value) &&
+  !(value instanceof Date);
+
+/** Whitespace, a line comment, or a block comment. */
+const SPACE = /\s+|\/\/[^\n\r]*|\/\*[\s\S]*?\*\//uy;
+
+/** An IdentifierName (ASCII): object keys, member names, keywords. */
+const IDENTIFIER = /[$A-Z_a-z][\w$]*/uy;
+
+/**
+ * A numeric literal: hex, octal, and binary forms, or a decimal with an
+ * optional fraction and exponent, `_` separators allowed between digits. A
+ * legacy octal (`017`) matches only its leading `0`, and the check on the
+ * following character rejects it, as strict-mode JavaScript does.
+ */
+const NUMBER =
+  /0[Xx][\dA-Fa-f](?:_?[\dA-Fa-f])*|0[Oo][0-7](?:_?[0-7])*|0[Bb][01](?:_?[01])*|(?:(?:0|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[Ee][+-]?\d(?:_?\d)*)?/uy;
+
+/** A character that may not directly follow a number (`1n`, `1px`, `017`). */
+const AFTER_NUMBER = /[\w$.]/u;
+
+const DIGIT = /\d/u;
+const HEX_DIGITS = /^[\dA-Fa-f]+$/u;
+
+/** A canonical array index: `0`, `12`, never `01`. */
+const INDEX = /^(?:0|[1-9]\d*)$/u;
+
+/** The largest Unicode code point, the cap on a `\u{…}` escape. */
+const MAX_CODE_POINT = 0x10_ff_ff;
+
+/** U+2028 and U+2029, the line terminators outside ASCII. */
+const LINE_SEPARATORS = new Set([
+  String.fromCodePoint(0x20_28),
+  String.fromCodePoint(0x20_29),
+]);
+
+const SIMPLE_ESCAPES = new Map([
+  ["b", "\b"],
+  ["f", "\f"],
+  ["n", "\n"],
+  ["r", "\r"],
+  ["t", "\t"],
+  ["v", "\v"],
+]);
+
+/** A key that, set through a literal, would replace the object's prototype. */
+const PROTO_KEY = "__proto__";
+
+/**
+ * `base[key]` on a front-matter value, own data only: a missing key reads as
+ * `undefined` (as it does at render time), stepping into `null` or
+ * `undefined` is not static (it would throw), and inherited members —
+ * methods, `constructor` — are never reached.
+ */
+const member = (base: EvaluatedValue, key: string): EvaluatedValue => {
+  if (base === null || base === undefined) {
+    return notStatic();
+  }
+  if (isText(base) || Array.isArray(base)) {
+    if (key === "length") {
+      return base.length;
+    }
+    return INDEX.test(key) ? base[Number(key)] : undefined;
+  }
+  return isValueMap(base) && Object.hasOwn(base, key) ? base[key] : undefined;
+};
+
+/** A recursive-descent reader over one expression's source. */
+class Reader {
+  readonly frontmatter: Record<string, EvaluatedValue> | undefined;
+  pos = 0;
+  readonly source: string;
+
+  constructor(
+    source: string,
+    frontmatter: Record<string, EvaluatedValue> | undefined
+  ) {
+    this.source = source;
+    this.frontmatter = frontmatter;
+  }
+
+  /** The character under the cursor (`""` at the end). */
+  get char(): string {
+    return this.source.charAt(this.pos);
+  }
+
+  get done(): boolean {
+    return this.pos >= this.source.length;
+  }
+
+  /** Match a sticky pattern at the cursor and consume it. */
+  match(pattern: RegExp): string | undefined {
+    pattern.lastIndex = this.pos;
+    const found = pattern.exec(this.source)?.[0];
+    if (found !== undefined) {
+      this.pos += found.length;
+    }
+    return found;
+  }
+
+  /** Skip whitespace and comments. */
+  space(): void {
+    let skipped = this.match(SPACE);
+    while (skipped !== undefined) {
+      skipped = this.match(SPACE);
+    }
+  }
+
+  /** Consume `expected` (after any space), or stop. */
+  expect(expected: string): void {
+    this.space();
+    if (!this.source.startsWith(expected, this.pos)) {
+      notStatic();
+    }
+    this.pos += expected.length;
+  }
+
+  value(): EvaluatedValue {
+    this.space();
+    const { char } = this;
+    if (char === "{") {
+      return this.object();
+    }
+    if (char === "[") {
+      return this.array();
+    }
+    if (char === '"' || char === "'") {
+      return this.string(char);
+    }
+    if (char === "`") {
+      return this.template();
+    }
+    if (char === "-") {
+      this.pos += 1;
+      // `--1` is a decrement, not two negations.
+      const operand = this.char === "-" ? notStatic() : this.value();
+      return isNumber(operand) ? -operand : notStatic();
+    }
+    return this.number() ?? this.name();
+  }
+
+  number(): number | undefined {
+    const text = this.match(NUMBER);
+    if (text === undefined) {
+      return;
+    }
+    if (
+      AFTER_NUMBER.test(this.char) ||
+      (text === "0" && DIGIT.test(this.char))
+    ) {
+      return notStatic();
+    }
+    return Number(text.replaceAll("_", ""));
+  }
+
+  /** A keyword literal, or `frontmatter` and its member steps. */
+  name(): EvaluatedValue {
+    const name = this.match(IDENTIFIER);
+    if (name === "true") {
+      return true;
+    }
+    if (name === "false") {
+      return false;
+    }
+    if (name === "null") {
+      return null;
+    }
+    if (name === "undefined") {
+      return undefined;
+    }
+    if (name !== "frontmatter") {
+      return notStatic();
+    }
+    let current: EvaluatedValue = this.frontmatter;
+    for (;;) {
+      this.space();
+      if (this.char === ".") {
+        this.pos += 1;
+        this.space();
+        current = member(current, this.match(IDENTIFIER) ?? notStatic());
+      } else if (this.char === "[") {
+        this.pos += 1;
+        const key = this.value();
+        this.expect("]");
+        current = member(
+          current,
+          isText(key) || isNumber(key) ? String(key) : notStatic()
+        );
+      } else {
+        return current;
+      }
+    }
+  }
+
+  object(): EvaluatedValue {
+    this.pos += 1;
+    const out: { [key: string]: EvaluatedValue } = {};
+    for (;;) {
+      this.space();
+      if (this.char === "}") {
+        this.pos += 1;
+        return out;
+      }
+      const key = this.key();
+      this.expect(":");
+      out[key] = this.value();
+      this.space();
+      if (this.char === ",") {
+        this.pos += 1;
+      } else if (this.char !== "}") {
+        return notStatic();
+      }
+    }
+  }
+
+  /** An object key: a name, a string, or a number (as its canonical string). */
+  key(): string {
+    const { char } = this;
+    let key: string;
+    if (char === '"' || char === "'") {
+      key = this.string(char);
+    } else {
+      const number = this.number();
+      key =
+        number === undefined
+          ? (this.match(IDENTIFIER) ?? notStatic())
+          : String(number);
+    }
+    // `{ __proto__: … }` sets the prototype rather than a property.
+    return key === PROTO_KEY ? notStatic() : key;
+  }
+
+  array(): EvaluatedValue[] {
+    this.pos += 1;
+    const out: EvaluatedValue[] = [];
+    for (;;) {
+      this.space();
+      if (this.char === "]") {
+        this.pos += 1;
+        return out;
+      }
+      out.push(this.value());
+      this.space();
+      if (this.char === ",") {
+        this.pos += 1;
+      } else if (this.char !== "]") {
+        return notStatic();
+      }
+    }
+  }
+
+  string(quote: string): string {
+    this.pos += 1;
+    let out = "";
+    for (;;) {
+      const { char } = this;
+      if (this.done || char === "\n" || char === "\r") {
+        return notStatic();
+      }
+      this.pos += 1;
+      if (char === quote) {
+        return out;
+      }
+      out += char === "\\" ? this.escape() : char;
+    }
+  }
+
+  template(): string {
+    this.pos += 1;
+    let out = "";
+    for (;;) {
+      if (this.done) {
+        return notStatic();
+      }
+      const { char } = this;
+      this.pos += 1;
+      if (char === "`") {
+        return out;
+      }
+      if (char === "\\") {
+        out += this.escape();
+      } else if (char === "$" && this.char === "{") {
+        this.pos += 1;
+        out += String(this.value());
+        this.expect("}");
+      } else if (char === "\r") {
+        // A raw line break in a template reads as `\n`, `\r\n` included.
+        if (this.char === "\n") {
+          this.pos += 1;
+        }
+        out += "\n";
+      } else {
+        out += char;
+      }
+    }
+  }
+
+  /** What an escape after `\` stands for, under strict-mode rules. */
+  escape(): string {
+    if (this.done) {
+      return notStatic();
+    }
+    const { char } = this;
+    this.pos += 1;
+    if (DIGIT.test(char)) {
+      // `\0` is NUL; octal escapes, `\8`, and `\9` are errors in strict code.
+      return char === "0" && !DIGIT.test(this.char) ? "\0" : notStatic();
+    }
+    if (char === "x") {
+      return String.fromCodePoint(this.hex(2));
+    }
+    if (char === "u") {
+      return String.fromCodePoint(
+        this.char === "{" ? this.codePoint() : this.hex(4)
+      );
+    }
+    if (char === "\r") {
+      // A line continuation: `\` and the line break stand for nothing.
+      if (this.char === "\n") {
+        this.pos += 1;
+      }
+      return "";
+    }
+    if (char === "\n" || LINE_SEPARATORS.has(char)) {
+      return "";
+    }
+    return SIMPLE_ESCAPES.get(char) ?? char;
+  }
+
+  /** Exactly `length` hex digits, as a code point. */
+  hex(length: number): number {
+    const digits = this.source.slice(this.pos, this.pos + length);
+    if (digits.length !== length || !HEX_DIGITS.test(digits)) {
+      return notStatic();
+    }
+    this.pos += length;
+    return Number.parseInt(digits, 16);
+  }
+
+  /** A braced `\u{…}` code point, the cursor on its `{`. */
+  codePoint(): number {
+    const end = this.source.indexOf("}", this.pos);
+    const digits = end === -1 ? "" : this.source.slice(this.pos + 1, end);
+    const code = HEX_DIGITS.test(digits) ? Number.parseInt(digits, 16) : -1;
+    if (code < 0 || code > MAX_CODE_POINT) {
+      return notStatic();
+    }
+    this.pos = end + 1;
+    return code;
+  }
+}
+
+/**
+ * Read `raw` — an attribute expression's source — as static data, with
+ * `frontmatter` (the page's front matter, when the caller has it) behind
+ * `frontmatter.<path>` references. Never executes anything.
+ */
+export const readStaticExpression = (
+  raw: string,
+  frontmatter?: Record<string, EvaluatedValue>
+): StaticExpressionResult => {
+  const reader = new Reader(raw, frontmatter);
+  try {
+    const value = reader.value();
+    reader.space();
+    return reader.done ? { ok: true, value } : { ok: false, value: undefined };
+  } catch {
+    // Not literal data (or nested past the stack): keep the JSX as written.
+    return { ok: false, value: undefined };
+  }
+};

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,18 +87,18 @@ 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
   );
 };
 
 /**
  * Resolve `<Visibility>` blocks for agent-facing Markdown (llms-full.txt, the
- * `.md`/`.mdx` mirrors, MCP tools, Ask AI grounding): `for="web"` content is
+ * `.md`/`.mdx` mirrors, MCP tools, assistant grounding): `for="web"` content is
  * removed and `for="agents"` content is unwrapped.
  */
 export const applyAgentVisibility = (markdown: string): string =>

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";
@@ -64,6 +65,9 @@ const adapterScripts = (
     case "cloudflare": {
       return cloudflareHead(adapter.options);
     }
+    case "databuddy": {
+      return databuddyHead(adapter.options);
+    }
     case "fathom": {
       return fathomHead(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";

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";
@@ -27,6 +28,7 @@ export const analyticsAdapterSchema = z.discriminatedUnion("kind", [
   clarityAdapterSchema,
   clearbitAdapterSchema,
   cloudflareAdapterSchema,
+  databuddyAdapterSchema,
   fathomAdapterSchema,
   googleAnalyticsAdapterSchema,
   googleTagManagerAdapterSchema,