@agent-native/core 0.98.1 → 0.98.2

package/corpus/core/src/client/analytics.ts

@@ -89,6 +89,13 @@ export type ConfigureTrackingOptions = {
   /** First-party analytics track endpoint. */
   endpoint?: string;
   getDefaultProps?: GetDefaultProps;
+  /**
+   * Disable content-capturing analytics such as interaction autocapture and
+   * session replay while retaining pageviews, explicit events, and Sentry.
+   */
+  contentCapture?: boolean;
+  /** Resolve content capture synchronously for each browser pathname. */
+  contentCaptureForPath?: (pathname: string) => boolean;
   sessionReplay?: boolean | SessionReplayOptions;
   /**
    * First-party, Sentry-style error capture. Auto-captures uncaught errors
@@ -132,6 +139,8 @@ let _errorCaptureDisposer: (() => void) | null = null;
 let _sessionReplayModuleForCapture:
   | typeof import("./session-replay.js")
   | null = null;
+let _trackingContentCaptureEnabled = true;
+let _contentCaptureForPath: ((pathname: string) => boolean) | null = null;
 // Buffer for setSentryUser calls made before Sentry has initialized.
 // `undefined` means "no pending update"; `null` means "pending clear".
 let _pendingSentryUser: SentryUser | null | undefined = undefined;
@@ -575,7 +584,10 @@ function ensureAmplitude(): boolean {
   const key = (import.meta.env as Record<string, string | undefined>)
     ?.VITE_AMPLITUDE_API_KEY;
   if (!key) return false;
-  amplitude.init(key, { autocapture: true });
+  // Standard pageviews and explicit events are emitted below. Keep SDK-level
+  // DOM/network autocapture off so rendered user content is never collected as
+  // an implicit analytics side effect.
+  amplitude.init(key, { autocapture: false });
   _amplitudeInitialized = true;
   return true;
 }
@@ -896,7 +908,11 @@ export function setSentryUser(
     clearTrackingIdentity();
   }
   _trackingIdentityResolved = true;
-  if (shouldRetryReplay && _sessionReplayOptions?.requireSignedInUser) {
+  if (
+    shouldRetryReplay &&
+    _trackingContentCaptureEnabled &&
+    _sessionReplayOptions?.requireSignedInUser
+  ) {
     void startConfiguredSessionReplay(_sessionReplayOptions);
   }
   if (_sentryInitialized) {
@@ -1004,6 +1020,11 @@ export function configureTracking(options: ConfigureTrackingOptions): void {
   if (options.getDefaultProps) {
     _getDefaultProps = options.getDefaultProps;
   }
+  _contentCaptureForPath = options.contentCaptureForPath ?? null;
+  _trackingContentCaptureEnabled =
+    _contentCaptureForPath && typeof window !== "undefined"
+      ? _contentCaptureForPath(window.location.pathname)
+      : options.contentCapture !== false;
   if (typeof window !== "undefined") {
     ensureSentry();
     ensureAmplitude();
@@ -1011,14 +1032,37 @@ export function configureTracking(options: ConfigureTrackingOptions): void {
     installLlmConnectionRefresh();
     installTrackingAuthSessionRefresh();
     installPageviewTracking();
-    maybeInstallSessionReplay(options.sessionReplay, {
-      endpoint: options.endpoint,
-      publicKey,
-    });
+    maybeInstallSessionReplay(
+      options.sessionReplay,
+      {
+        endpoint: options.endpoint,
+        publicKey,
+      },
+      _trackingContentCaptureEnabled,
+    );
     maybeInstallErrorCapture(options.errorCapture);
   }
 }
 
+export function setTrackingContentCaptureEnabled(enabled: boolean): void {
+  if (_trackingContentCaptureEnabled === enabled) return;
+  _trackingContentCaptureEnabled = enabled;
+  if (enabled) {
+    if (_sessionReplayOptions) {
+      void startConfiguredSessionReplay(_sessionReplayOptions);
+    }
+  } else {
+    void stopSessionReplay("content-capture-disabled");
+  }
+}
+
+function syncTrackingContentCaptureForLocation(): void {
+  if (!_contentCaptureForPath) return;
+  setTrackingContentCaptureEnabled(
+    _contentCaptureForPath(window.location.pathname),
+  );
+}
+
 /**
  * Lazily load the session-replay module so error capture can read the active
  * replay id and surface manual captures on the replay timeline without a
@@ -1254,11 +1298,12 @@ function replayEndpointFromTrackingEndpoint(value: string): string | undefined {
 function maybeInstallSessionReplay(
   config: boolean | SessionReplayOptions | undefined,
   tracking?: { endpoint?: string; publicKey?: string },
+  start = true,
 ): void {
   if (typeof window === "undefined") return;
   const options = configuredSessionReplayOptions(config, tracking);
-  if (!options) return;
   _sessionReplayOptions = options;
+  if (!options || !start) return;
   void startConfiguredSessionReplay(options);
 }
 
@@ -1284,11 +1329,24 @@ async function startConfiguredSessionReplay(
 ): Promise<SessionReplayStartResult | null> {
   if (_sessionReplayStartPromise) return _sessionReplayStartPromise;
   _sessionReplayStartPromise = (async () => {
+    if (!_trackingContentCaptureEnabled) {
+      return { started: false, reason: "disabled" as const };
+    }
     if (!(await waitForSessionReplayAuthIfRequired(options))) {
       return { started: false, reason: "missing-user-id" as const };
     }
+    if (!_trackingContentCaptureEnabled) {
+      return { started: false, reason: "disabled" as const };
+    }
     const mod = await import("./session-replay.js");
-    return mod.startSessionReplay(options);
+    if (!_trackingContentCaptureEnabled) {
+      return { started: false, reason: "disabled" as const };
+    }
+    return mod.startSessionReplay({
+      ...options,
+      shouldStart: () =>
+        _trackingContentCaptureEnabled && (options.shouldStart?.() ?? true),
+    });
   })()
     .catch(() => ({ started: false, reason: "import-failed" as const }))
     .finally(() => {
@@ -1300,23 +1358,37 @@ async function startConfiguredSessionReplay(
 export async function startSessionReplay(
   options: SessionReplayOptions = {},
 ): Promise<SessionReplayStartResult> {
+  if (!_trackingContentCaptureEnabled) {
+    return { started: false, reason: "disabled" };
+  }
   const configured = configuredSessionReplayOptions(options) ?? options;
   if (!(await waitForSessionReplayAuthIfRequired(configured))) {
     return { started: false, reason: "missing-user-id" };
   }
   const mod = await import("./session-replay.js");
-  return mod.startSessionReplay(configured);
+  return mod.startSessionReplay({
+    ...configured,
+    shouldStart: () =>
+      _trackingContentCaptureEnabled && (configured.shouldStart?.() ?? true),
+  });
 }
 
 export async function maybeStartSessionReplay(
   options: SessionReplayOptions = {},
 ): Promise<SessionReplayStartResult> {
+  if (!_trackingContentCaptureEnabled) {
+    return { started: false, reason: "disabled" };
+  }
   const configured = configuredSessionReplayOptions(options) ?? options;
   if (!(await waitForSessionReplayAuthIfRequired(configured))) {
     return { started: false, reason: "missing-user-id" };
   }
   const mod = await import("./session-replay.js");
-  return mod.maybeStartSessionReplay(configured);
+  return mod.maybeStartSessionReplay({
+    ...configured,
+    shouldStart: () =>
+      _trackingContentCaptureEnabled && (configured.shouldStart?.() ?? true),
+  });
 }
 
 export async function stopSessionReplay(reason = "manual"): Promise<void> {
@@ -1371,15 +1443,17 @@ function pageviewKey(): string {
 
 function pageviewProperties(reason: string): Record<string, unknown> {
   const properties: Record<string, unknown> = {
-    url: scrubUrl(window.location.href),
+    url: !_trackingContentCaptureEnabled
+      ? window.location.origin + window.location.pathname
+      : scrubUrl(window.location.href),
     path: window.location.pathname,
     hostname: window.location.hostname,
     navigation_type: reason,
   };
-  if (window.location.search) {
+  if (_trackingContentCaptureEnabled && window.location.search) {
     properties.search = scrubUrl(window.location.search);
   }
-  if (typeof document !== "undefined") {
+  if (_trackingContentCaptureEnabled && typeof document !== "undefined") {
     if (document.referrer) {
       properties.referrer = scrubUrl(document.referrer);
     }
@@ -1400,6 +1474,9 @@ function emitPageview(reason: string): void {
 }
 
 function schedulePageview(reason: string): void {
+  if (!_trackingContentCaptureEnabled) {
+    void stopSessionReplay("local-plan-privacy");
+  }
   const run = () => emitPageview(reason);
   const pendingStartupContext: Array<Promise<void>> = [];
   if (_llmConnectionRefresh && !_llmConnectionStatus) {
@@ -1436,17 +1513,22 @@ function installPageviewTracking(): void {
 
   window.history.pushState = function pushState(...args) {
     const result = originalPushState.apply(this, args);
+    syncTrackingContentCaptureForLocation();
     schedulePageview("pushState");
     return result;
   };
 
   window.history.replaceState = function replaceState(...args) {
     const result = originalReplaceState.apply(this, args);
+    syncTrackingContentCaptureForLocation();
     schedulePageview("replaceState");
     return result;
   };
 
-  window.addEventListener("popstate", () => schedulePageview("popstate"));
+  window.addEventListener("popstate", () => {
+    syncTrackingContentCaptureForLocation();
+    schedulePageview("popstate");
+  });
 }
 
 function sendAgentNativeAnalytics(

package/corpus/core/src/client/index.ts

@@ -192,6 +192,10 @@ export {
   getChangeVersion,
   bumpChangeVersion,
 } from "./use-change-version.js";
+export {
+  useDemoModeStatus,
+  type DemoModeStatus,
+} from "./use-demo-mode-status.js";
 export { useReconciledState } from "./use-external-value.js";
 export {
   buildDynamicAgentSuggestions,
@@ -751,6 +755,7 @@ export {
   trackEvent,
   trackSessionStatus,
   configureTracking,
+  setTrackingContentCaptureEnabled,
   maybeStartSessionReplay,
   startSessionReplay,
   stopSessionReplay,

package/corpus/core/src/client/session-replay.ts

@@ -109,6 +109,8 @@ export interface SessionReplayNetworkOptions {
 
 export interface SessionReplayOptions {
   enabled?: boolean;
+  /** Rechecked immediately before rrweb starts to cancel deferred startup. */
+  shouldStart?: () => boolean;
   publicKey?: string;
   endpoint?: string;
   requireSignedInUser?: boolean;
@@ -208,6 +210,7 @@ interface NormalizedSessionReplayOptions {
   /** Null disables network capture entirely. */
   network: NormalizedCaptureOptions | null;
   extraProperties?: SessionReplayOptions["extraProperties"];
+  shouldStart?: SessionReplayOptions["shouldStart"];
 }
 
 interface NormalizedCaptureOptions {
@@ -656,6 +659,7 @@ function normalizeOptions(
       DEFAULT_MAX_NETWORK_EVENTS,
     ),
     extraProperties: options.extraProperties,
+    shouldStart: options.shouldStart,
   };
 }
 
@@ -1950,6 +1954,9 @@ export async function startSessionReplay(
   options: SessionReplayOptions = {},
 ): Promise<SessionReplayStartResult> {
   if (options.enabled === false) return { started: false, reason: "disabled" };
+  if (options.shouldStart && !options.shouldStart()) {
+    return { started: false, reason: "disabled" };
+  }
   if (typeof window === "undefined" || typeof document === "undefined") {
     return { started: false, reason: "not-browser" };
   }
@@ -2032,6 +2039,9 @@ async function startSessionReplayRecorder(
   } catch {
     return { started: false, reason: "import-failed", sessionId, sampled };
   }
+  if (normalized.shouldStart && !normalized.shouldStart()) {
+    return { started: false, reason: "disabled", sessionId, sampled };
+  }
 
   const replaySession = getOrCreateReplaySession(sessionId);
   state.options = normalized;

package/corpus/core/src/client/settings/DemoModeSection.tsx

@@ -13,40 +13,18 @@
  */
 
 import { IconEyeOff } from "@tabler/icons-react";
-import { useQuery } from "@tanstack/react-query";
 import { useEffect, useState } from "react";
 
 import { agentNativePath } from "../api-path.js";
-import { useChangeVersion } from "../use-change-version.js";
+import { useDemoModeStatus } from "../use-demo-mode-status.js";
 
-interface DemoStatus {
-  enabled?: boolean;
-  forced?: boolean;
-}
-
-const DEMO_STATUS_URL = agentNativePath("/_agent-native/demo/status");
 const DEMO_MODE_WRITE_URL = agentNativePath(
   "/_agent-native/application-state/demo-mode",
 );
 
 export function DemoModeSection() {
   const [enabled, setEnabled] = useState<boolean | null>(null);
-  const demoModeVersion = useChangeVersion("app-state:demo-mode");
-
-  const { data } = useQuery({
-    queryKey: ["agent-native", "demo-mode", demoModeVersion],
-    queryFn: async () => {
-      const res = await fetch(DEMO_STATUS_URL, {
-        credentials: "same-origin",
-      });
-      if (!res.ok) return null;
-      return (await res.json()) as DemoStatus | null;
-    },
-    staleTime: Infinity,
-  });
-
-  const serverEnabled = data?.enabled;
-  const forced = data?.forced === true;
+  const { enabled: serverEnabled, forced, isLoading } = useDemoModeStatus();
 
   // Surface the server value once it arrives (and on subsequent polls), but
   // never clobber an in-flight optimistic toggle with a stale read. When
@@ -54,12 +32,10 @@ export function DemoModeSection() {
   useEffect(() => {
     if (forced) {
       setEnabled(true);
-    } else if (typeof serverEnabled === "boolean") {
+    } else if (!isLoading) {
       setEnabled((prev) => (prev === null ? serverEnabled : prev));
-    } else if (serverEnabled === undefined && data !== undefined) {
-      setEnabled((prev) => (prev === null ? false : prev));
     }
-  }, [serverEnabled, forced, data]);
+  }, [serverEnabled, forced, isLoading]);
 
   const toggle = async (next: boolean) => {
     if (forced) return;

package/corpus/core/src/client/url-scrub.ts

@@ -12,6 +12,7 @@ const SENSITIVE_QUERY_PARAMS = new Set([
   "code",
   "share",
   "share_token",
+  "bridge",
 ]);
 
 export function scrubUrl(url: string | undefined): string | undefined {
@@ -26,6 +27,18 @@ export function scrubUrl(url: string | undefined): string | undefined {
         mutated = true;
       }
     }
+    if (u.hash.includes("=")) {
+      const hashParams = new URLSearchParams(u.hash.slice(1));
+      let hashMutated = false;
+      for (const key of Array.from(hashParams.keys())) {
+        if (SENSITIVE_QUERY_PARAMS.has(key.toLowerCase())) {
+          hashParams.set(key, "<redacted>");
+          mutated = true;
+          hashMutated = true;
+        }
+      }
+      if (hashMutated) u.hash = hashParams.toString();
+    }
     if (!mutated) return url;
     // If the original URL was relative, return only the path/query/fragment.
     if (u.origin === "http://placeholder.local") {

package/corpus/core/src/client/use-demo-mode-status.ts

@@ -0,0 +1,44 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { agentNativePath } from "./api-path.js";
+import { useChangeVersion } from "./use-change-version.js";
+
+interface DemoModeStatusResponse {
+  enabled?: boolean;
+  forced?: boolean;
+}
+
+export interface DemoModeStatus {
+  enabled: boolean;
+  forced: boolean;
+  isLoading: boolean;
+}
+
+const DEMO_STATUS_URL = agentNativePath("/_agent-native/demo/status");
+
+/**
+ * Reads the effective Demo mode status for the current user. The shared
+ * change-version stream advances after Demo mode application state changes,
+ * so mounted consumers refresh without polling or duplicating the route call.
+ */
+export function useDemoModeStatus(): DemoModeStatus {
+  const demoModeVersion = useChangeVersion("app-state:demo-mode");
+
+  const { data, isLoading } = useQuery({
+    queryKey: ["agent-native", "demo-mode", demoModeVersion],
+    queryFn: async () => {
+      const res = await fetch(DEMO_STATUS_URL, {
+        credentials: "same-origin",
+      });
+      if (!res.ok) return null;
+      return (await res.json()) as DemoModeStatusResponse | null;
+    },
+    staleTime: Infinity,
+  });
+
+  return {
+    enabled: data?.enabled === true,
+    forced: data?.forced === true,
+    isLoading,
+  };
+}

package/corpus/templates/analytics/AGENTS.md

@@ -39,6 +39,14 @@ details live in `.agents/skills/`.
   Prometheus credential slot. Treat it as demo-environment data: do not use it
   for `REAL_DATA_REQUIRED`, saved analyses, or real user analytics answers
   unless the user explicitly asks to inspect the demo dashboard.
+- Framework Demo mode is separate from the built-in `demo` source. While Demo
+  mode is enabled, Analytics line and area charts reshape each returned numeric
+  series into a deterministic, natural-looking upward trend using that series'
+  actual minimum, maximum, and normalized volatility. Smooth source series stay
+  smooth; spiky source series keep larger swings. This is presentation-only:
+  query results, tables, metrics, exports, and non-time-series charts remain
+  unchanged, so do not cite the displayed intermediate line/area points as
+  retrieved source values.
 - Every analytical answer should include enough audit context for the user to
   trust it: source(s), time window, filters, sample size or row count,
   join/match method when relevant, and caveats/gaps.

package/corpus/templates/analytics/app/components/dashboard/SqlChart.tsx

@@ -1,4 +1,4 @@
-import { useT } from "@agent-native/core/client";
+import { useDemoModeStatus, useT } from "@agent-native/core/client";
 import { EmbeddedExtension } from "@agent-native/core/client/extensions";
 import {
   IconArrowsSort,
@@ -54,6 +54,7 @@ import {
 import { Skeleton } from "@/components/ui/skeleton";
 
 const PAGE_SIZE_OPTIONS = [10, 25, 50, 100];
+import { createDemoChartTrendRows } from "@/lib/demo-chart-trend";
 import { useSqlQuery } from "@/lib/sql-query";
 import { serializePanelSql } from "@/pages/adhoc/sql-dashboard/panel-sql";
 import { pivotRows } from "@/pages/adhoc/sql-dashboard/pivot";
@@ -994,6 +995,7 @@ export function SqlChart({
   onExportCsvChange,
 }: SqlChartProps) {
   const t = useT();
+  const { enabled: demoModeEnabled } = useDemoModeStatus();
   // Hooks must be called unconditionally before any early return.
   const isSection = panel.chartType === "section";
   const isExtension = panel.chartType === "extension";
@@ -1024,7 +1026,7 @@ export function SqlChart({
   const error =
     rawRows.length === 0 ? (result?.error ?? queryErrorMessage) : undefined;
 
-  const { rows, forcedYKeys } = useMemo(() => {
+  const { rows: queryRows, forcedYKeys } = useMemo(() => {
     if (panel.config?.pivot && rawRows.length) {
       const pivoted = pivotRows(rawRows, panel.config.pivot);
       return { rows: pivoted.rows, forcedYKeys: pivoted.seriesKeys };
@@ -1033,8 +1035,20 @@ export function SqlChart({
   }, [rawRows, panel.config?.pivot]);
 
   const { xKey, yKeys } = useMemo(
-    () => detectKeys(rows, panel.config, forcedYKeys),
-    [rows, panel.config, forcedYKeys],
+    () => detectKeys(queryRows, panel.config, forcedYKeys),
+    [queryRows, panel.config, forcedYKeys],
+  );
+  const shouldCreateDemoTrend =
+    demoModeEnabled &&
+    (panel.chartType === "line" ||
+      panel.chartType === "area" ||
+      (panel.chartType as string) === "stacked-area");
+  const rows = useMemo(
+    () =>
+      shouldCreateDemoTrend
+        ? createDemoChartTrendRows(queryRows, yKeys, panel.id)
+        : queryRows,
+    [queryRows, yKeys, panel.id, shouldCreateDemoTrend],
   );
 
   // Section panels are pure layout — no query, no chart. Render a header with

package/corpus/templates/analytics/app/lib/demo-chart-trend.ts

@@ -0,0 +1,156 @@
+type DemoTrendSeed = string | number;
+
+function hashSeed(seed: string): number {
+  let hash = 2166136261;
+  for (let index = 0; index < seed.length; index += 1) {
+    hash ^= seed.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function createRandom(seed: string): () => number {
+  let state = hashSeed(seed);
+  return () => {
+    state += 0x6d2b79f5;
+    let value = state;
+    value = Math.imul(value ^ (value >>> 15), value | 1);
+    value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
+    return ((value ^ (value >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function clamp(value: number, minimum: number, maximum: number): number {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+
+function numericValue(value: unknown): number | null {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string" || value.trim() === "") return null;
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+
+function normalizedVolatility(
+  series: number[],
+  minimum: number,
+  range: number,
+) {
+  if (series.length < 3 || range === 0) return 0;
+  const normalized = series.map((value) => (value - minimum) / range);
+  const averageStep =
+    (normalized[normalized.length - 1] - normalized[0]) /
+    (normalized.length - 1);
+  const deviation = normalized
+    .slice(1)
+    .reduce(
+      (total, value, index) =>
+        total + Math.abs(value - normalized[index] - averageStep),
+      0,
+    );
+  return clamp((deviation / (normalized.length - 1)) * 1.4, 0, 1);
+}
+
+function normalizedTrend(
+  length: number,
+  volatilityScore: number,
+  random: () => number,
+): number[] {
+  if (length <= 1) return [0];
+  if (length === 2) return [0, 1];
+
+  const volatility = 0.015 + volatilityScore * (0.22 + random() * 0.12);
+  const noiseMemory = 0.78 - volatilityScore * 0.58;
+  let noise = 0;
+  const values = Array.from({ length }, (_, index) => {
+    if (index === 0) return 0;
+    if (index === length - 1) return 1;
+
+    const progress = index / (length - 1);
+    noise = noise * noiseMemory + (random() * 2 - 1) * (1 - noiseMemory);
+    const taperedNoise = noise * volatility * Math.sin(Math.PI * progress);
+    return clamp(progress + taperedNoise, 0.025, 0.975);
+  });
+
+  // Pullback count and depth follow the source's normalized volatility. A
+  // smooth source remains a gentle rise; a jagged source gets several seeded
+  // reversals. Spacing the reversals across the series prevents them from
+  // collapsing into one noisy patch.
+  if (length >= 5 && volatilityScore >= 0.12) {
+    const maximumPullbacks = Math.min(3, Math.floor((length - 2) / 2));
+    const pullbackCount = Math.max(
+      1,
+      Math.round(volatilityScore * maximumPullbacks),
+    );
+    for (let pullback = 0; pullback < pullbackCount; pullback += 1) {
+      const segmentCenter =
+        ((pullback + 1) * (length - 3)) / (pullbackCount + 1) + 1;
+      const jitter = (random() - 0.5) * Math.max(1, length / 10);
+      const dipIndex = Math.round(clamp(segmentCenter + jitter, 2, length - 2));
+      const center = dipIndex / (length - 1);
+      const amplitude = 0.025 + volatilityScore * (0.075 + random() * 0.12);
+      values[dipIndex - 1] = clamp(center + amplitude, 0.075, 0.925);
+      values[dipIndex] = clamp(center - amplitude, 0.05, 0.9);
+    }
+  }
+
+  return values;
+}
+
+/**
+ * Replace numeric chart series with a stable, seeded upward trend while
+ * retaining the query's original range and every non-series field. This is a
+ * presentation-only demo-mode transform: callers keep the real query result
+ * and opt individual line/area renderers into the returned rows.
+ */
+export function createDemoChartTrendRows(
+  rows: Record<string, unknown>[],
+  yKeys: string[],
+  seed: DemoTrendSeed,
+): Record<string, unknown>[] {
+  if (rows.length === 0 || yKeys.length === 0) return rows;
+
+  let output: Record<string, unknown>[] | null = null;
+
+  for (const yKey of yKeys) {
+    const points = rows.flatMap((row, rowIndex) => {
+      const numeric = numericValue(row[yKey]);
+      return numeric === null
+        ? []
+        : [{ rowIndex, numeric, original: row[yKey] }];
+    });
+
+    if (points.length < 2) continue;
+
+    const minimum = Math.min(...points.map((point) => point.numeric));
+    const maximum = Math.max(...points.map((point) => point.numeric));
+    if (minimum === maximum) continue;
+
+    const random = createRandom(`${String(seed)}:${yKey}`);
+    const range = maximum - minimum;
+    const volatilityScore = normalizedVolatility(
+      points.map((point) => point.numeric),
+      minimum,
+      range,
+    );
+    const trend = normalizedTrend(points.length, volatilityScore, random);
+    const useStringValues = points.every(
+      (point) => typeof point.original === "string",
+    );
+
+    output ??= rows.map((row) => ({ ...row }));
+    points.forEach((point, pointIndex) => {
+      const numeric =
+        pointIndex === 0
+          ? minimum
+          : pointIndex === points.length - 1
+            ? maximum
+            : minimum + trend[pointIndex] * range;
+      output![point.rowIndex][yKey] = useStringValues
+        ? String(numeric)
+        : numeric;
+    });
+  }
+
+  return output ?? rows;
+}

package/corpus/templates/analytics/changelog/2026-07-12-daily-dashboard-emails-reliably-include-the-complete-dashboa.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-12
+---
+
+Daily dashboard emails reliably include the complete dashboard image.

package/corpus/templates/analytics/changelog/2026-07-12-demo-mode-charts-trend-upward.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-12
+---
+
+Demo mode line and area charts now show unique upward trends while preserving each series' original range and volatility.

package/corpus/templates/analytics/server/jobs/dashboard-report.ts

@@ -56,6 +56,8 @@ export async function runDashboardReportsOnce(): Promise<{
             `[dashboard-report] Subscription ${sub.id} sent without a screenshot:`,
             message,
           );
+          await markDashboardReportResult(sub, "success", message);
+          continue;
         }
         await markDashboardReportResult(sub, "success");
       } catch (err: any) {