@agent-native/core 0.84.14 → 0.84.16

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2043
-- template files: 4919
+- template files: 4922

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @agent-native/core
 
+## 0.84.16
+
+### Patch Changes
+
+- 564460a: Add an optional `focus` flag to `setAgentChatContextItem` (and thread it through to the composer). Callers that mirror ambient UI state into chat context — such as a design canvas element selection — can now pass `focus: false` to stage the context chip without moving keyboard focus into the composer. This stops passive context staging from blurring and tearing down an in-progress inline text editor in the Design canvas (which re-fires on every selection and on each get-design poll during an agent run). Focus stays enabled by default, so existing callers are unchanged.
+- 2b27c0f: Avoid unsupported array helpers in Builder engine message caching and stabilize prep-load tests.
+- a4f5303: Keep background chat continuation markers and database pool detection aligned with the actual background function dispatch path.
+
+## 0.84.15
+
+### Patch Changes
+
+- 946ff86: Fix the "No LLM provider is connected" chat banner staying visible after a
+  provider is connected. The composer now clears that error once the engine
+  status flips to configured, and the status check no longer reads a stale
+  cached "missing" response after connecting.
+
 ## 0.84.14
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.84.14",
+  "version": "0.84.16",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -184,7 +184,7 @@
     "build": "tsgo && tsgo -p tsconfig.cli.json && node scripts/finalize-build.mjs && node scripts/check-dist-imports.mjs",
     "dev": "tsgo --watch",
     "typecheck": "tsgo --noEmit",
-    "test": "vitest --run src",
+    "test": "vitest --run src --maxWorkers=25%",
     "prepack": "tsx ../../scripts/sync-workspace-core-skills.ts --check && npm run build && cp ../../README.md ./README.md",
     "prepublishOnly": "npm run build"
   },

package/corpus/core/src/agent/durable-background.ts

@@ -149,6 +149,12 @@ export function resolveAgentChatProcessRunDispatchPath(): string {
   return AGENT_CHAT_PROCESS_RUN_PATH;
 }
 
+export function dispatchPathTargetsNetlifyBackgroundFunction(
+  dispatchPath: string,
+): boolean {
+  return dispatchPath.startsWith("/.netlify/functions/");
+}
+
 /**
  * Env flag for durable background runs. DEFAULT-OFF (opt-in): unset means
  * disabled; an app opts IN with an explicit truthy value (`true`/`1`/`yes`/`on`).

package/corpus/core/src/agent/engine/builder-engine.ts

@@ -193,9 +193,13 @@ class BuilderEngine implements AgentEngine {
     // content block so the entire conversation prefix is cached.
     let cachedMessages = messages;
     if (cacheEnabled && messages.length > 0) {
-      const lastUserIdx = [...messages].findLastIndex(
-        (m: any) => m.role === "user",
-      );
+      let lastUserIdx = -1;
+      for (let i = messages.length - 1; i >= 0; i -= 1) {
+        if ((messages[i] as any).role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
       if (lastUserIdx >= 0) {
         cachedMessages = [...messages];
         const lastMsg = { ...cachedMessages[lastUserIdx] } as any;

package/corpus/core/src/agent/production-agent.ts

@@ -54,6 +54,7 @@ import { computeProtectedSegmentIds } from "./context-xray/segments.js";
 import {
   AGENT_CHAT_BACKGROUND_RUN_FIELD,
   backgroundRuntimeDiagnosticDetail,
+  dispatchPathTargetsNetlifyBackgroundFunction,
   isAgentChatDurableBackgroundEnabled,
   resolveAgentChatProcessRunDispatchPath,
   shouldUseBackgroundFunctionTimeoutForWorker,
@@ -5017,7 +5018,7 @@ export function createProductionAgentHandler(
       let dispatched = false;
       const backgroundDispatchPath = resolveAgentChatProcessRunDispatchPath();
       const expectsNetlifyBackgroundFunction =
-        backgroundDispatchPath.startsWith("/.netlify/functions/");
+        dispatchPathTargetsNetlifyBackgroundFunction(backgroundDispatchPath);
       try {
         await fireInternalDispatch({
           event,
@@ -5313,6 +5314,12 @@ export function createProductionAgentHandler(
                 // its seq log starts clean; same turnId folds the assistant
                 // message across chunks.
                 const nextRunId = generateRunId();
+                const continuationDispatchPath =
+                  resolveAgentChatProcessRunDispatchPath();
+                const continuationExpectsNetlifyBackgroundFunction =
+                  dispatchPathTargetsNetlifyBackgroundFunction(
+                    continuationDispatchPath,
+                  );
                 try {
                   await fireInternalDispatch({
                     event,
@@ -5322,7 +5329,7 @@ export function createProductionAgentHandler(
                     // background:true; never shadowed because /.netlify/* is
                     // excluded from the /* catch-all) so each chunk keeps the
                     // 15-min budget; off-Netlify the in-process framework route.
-                    path: resolveAgentChatProcessRunDispatchPath(),
+                    path: continuationDispatchPath,
                     taskId: nextRunId,
                     body: {
                       ...body,
@@ -5332,7 +5339,7 @@ export function createProductionAgentHandler(
                         turnId: effectiveTurnId,
                         continuationCount: backgroundContinuationCount + 1,
                         backgroundFunctionRuntimeExpected:
-                          runsInBackgroundFunction,
+                          continuationExpectsNetlifyBackgroundFunction,
                       },
                     },
                   });

package/corpus/core/src/client/AssistantChat.tsx

@@ -648,8 +648,15 @@ export interface AssistantChatHandle {
   ): void;
   /** Programmatically prefill the composer without submitting. */
   prefillMessage(text: string): void;
-  /** Add or replace keyed context for the next composer submission. */
-  setComposerContextItem(item: AgentChatContextItem): void;
+  /**
+   * Add or replace keyed context for the next composer submission.
+   * Focuses the composer by default; pass `{ focus: false }` for passive
+   * context mirroring (e.g. canvas selection) that must not steal focus.
+   */
+  setComposerContextItem(
+    item: AgentChatContextItem,
+    options?: { focus?: boolean },
+  ): void;
   /** Remove a keyed context item from the composer. */
   removeComposerContextItem(key: string): void;
   /** Clear all staged context items from the composer. */
@@ -1205,6 +1212,17 @@ const AssistantChatInner = forwardRef<
   );
   const missingApiKey = agentEngineConfigured.missing;
   const isComposerDisabled = missingApiKey || composerDisabled;
+  // Once a provider connects, `useAgentEngineConfigured` flips to "configured"
+  // off the `agent-engine:configured-changed` event. The composer banner is a
+  // separate piece of state that would otherwise only clear on manual dismiss
+  // or the next successful send, so drop the stale "no LLM provider" message
+  // here to match the resolved connection.
+  useEffect(() => {
+    if (agentEngineConfigured.state !== "configured") return;
+    setComposerError((current) =>
+      current === LLM_MISSING_CREDENTIALS_MESSAGE ? null : current,
+    );
+  }, [agentEngineConfigured.state]);
   const missingApiKeySetupAboveComposer =
     missingApiKeySetupLayout === "sidebar";
   // Increments each time the user tries to chat while no LLM is connected.
@@ -2958,9 +2976,17 @@ const AssistantChatInner = forwardRef<
         tiptapRef.current?.setText(text);
         tiptapRef.current?.focus();
       },
-      setComposerContextItem(item: AgentChatContextItem) {
+      setComposerContextItem(
+        item: AgentChatContextItem,
+        options?: { focus?: boolean },
+      ) {
         stageComposerContextItem(item);
-        tiptapRef.current?.focus();
+        // Only pull focus into the composer for explicit user gestures.
+        // Passive context mirroring (e.g. a canvas selection staged with
+        // openSidebar:false) must not steal focus — doing so blurs an active
+        // inline text editor living in the design canvas iframe and tears it
+        // down the instant it opens.
+        if (options?.focus !== false) tiptapRef.current?.focus();
       },
       removeComposerContextItem(key: string) {
         removeComposerContextItem(key);

package/corpus/core/src/client/MultiTabAssistantChat.tsx

@@ -1118,10 +1118,14 @@ export function MultiTabAssistantChat({
   const postMessageSubmissionsDisabled = props.composerDisabled === true;
 
   const setContextInTab = useCallback(
-    (threadId: string, item: AgentChatContextItem) => {
+    (
+      threadId: string,
+      item: AgentChatContextItem,
+      options?: { focus?: boolean },
+    ) => {
       const ref = chatRefs.current.get(threadId);
       if (ref) {
-        ref.setComposerContextItem(item);
+        ref.setComposerContextItem(item, options);
         return;
       }
       const existing = pendingContextItems.current.get(threadId) ?? [];
@@ -1712,7 +1716,11 @@ export function MultiTabAssistantChat({
         if (postMessageSubmissionsDisabled) return;
         const currentTabId = activeThreadIdRef.current;
         if (!currentTabId) return;
-        setContextInTab(currentTabId, item);
+        // Focus defaults to true; a caller opts out with `focus: false` for
+        // passive context (e.g. a canvas selection) so staging never steals
+        // focus from an in-progress inline editor.
+        const focus = (event.data.data?.focus as boolean | undefined) !== false;
+        setContextInTab(currentTabId, item, { focus });
         return;
       }
       if (event.data?.type === AGENT_CHAT_REMOVE_CONTEXT_MESSAGE_TYPE) {

package/corpus/core/src/client/agent-chat.ts

@@ -113,6 +113,13 @@ export interface AgentChatContextSetOptions extends AgentChatContextItem {
    * Defaults to true so the user can see the staged context.
    */
   openSidebar?: boolean;
+  /**
+   * Whether to move keyboard focus into the composer when staging the item.
+   * Defaults to true. Pass `false` for context that mirrors ambient UI state
+   * (e.g. a canvas element selection) so staging never steals focus from an
+   * unrelated editor — such as an inline text editor in a design canvas.
+   */
+  focus?: boolean;
 }
 
 /** @deprecated Use `AgentChatContextSetOptions` instead. */
@@ -865,9 +872,17 @@ export function setAgentChatContextItem(
   publishAgentChatContextItems(
     withReplacedAgentChatContextItem(agentChatContextState.items, item),
   );
-  postAgentChatContextMessage(AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE, item, {
-    openSidebar: opts.openSidebar !== false,
-  });
+  // Forward an explicit `focus: false` so the receiving composer can stage the
+  // chip without stealing focus. Focus stays enabled by default (field omitted)
+  // for every existing caller.
+  const messageData = opts.focus === false ? { ...item, focus: false } : item;
+  postAgentChatContextMessage(
+    AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE,
+    messageData,
+    {
+      openSidebar: opts.openSidebar !== false,
+    },
+  );
 }
 
 /** @deprecated Use `setAgentChatContextItem` instead. */

package/corpus/core/src/client/use-agent-engine-configured.ts

@@ -35,10 +35,13 @@ async function fetchStatusJson(
     }, timeoutMs);
   });
 
-  const request = fetch(
-    agentNativePath(path),
-    controller ? { signal: controller.signal } : undefined,
-  )
+  // Never serve a stale status from the HTTP cache: this is re-fetched right
+  // after a provider connects, and a cached "missing" would keep the composer
+  // gate and error banner pinned even though a provider is now configured.
+  const request = fetch(agentNativePath(path), {
+    cache: "no-store",
+    ...(controller ? { signal: controller.signal } : {}),
+  })
     .then((r) => (r.ok ? r.json() : null))
     .catch(() => null)
     .finally(() => {

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

@@ -837,13 +837,22 @@ export function neonPoolMax(): number {
  * (agent/durable-background.ts), replicated here to avoid a `db` → `agent`
  * import cycle. Keep the signals in sync with that function.
  */
-function isBackgroundFunctionPoolContext(): boolean {
+export function isBackgroundFunctionPoolContext(): boolean {
   if (
     (globalThis as Record<string, unknown>)
       .__AGENT_NATIVE_BACKGROUND_RUNTIME__ === true
   ) {
     return true;
   }
+  // Set by the HMAC-authenticated agent-chat `_process-run` route before it
+  // re-enters the normal chat handler. This mirrors the marker-only runtime
+  // proof used by durable-background.ts without importing agent code into db/.
+  if (
+    (globalThis as Record<string, unknown>)
+      .__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ === true
+  ) {
+    return true;
+  }
   const lambdaName = process.env.AWS_LAMBDA_FUNCTION_NAME;
   if (
     typeof lambdaName === "string" &&

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -34,8 +34,9 @@ import {
 } from "../agent/app-model-defaults.js";
 import { DEFAULT_ANTHROPIC_MODEL } from "../agent/default-model.js";
 import {
+  AGENT_CHAT_BACKGROUND_RUN_FIELD,
   AGENT_CHAT_PROCESS_RUN_PATH,
-  extractProcessRunId,
+  backgroundRunMarkerExpectsBackgroundRuntime,
   isInBackgroundFunctionRuntime,
   prepareProcessRunRequest,
 } from "../agent/durable-background.js";
@@ -7993,18 +7994,6 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             setResponseStatus(event, 405);
             return { error: "Method not allowed" };
           }
-          // DIAGNOSTIC: load the run-store diagnostic recorder. Each stage we
-          // reach is written onto the run row (diag_stage) so a silent failure
-          // INSIDE the Netlify background function — whose logs we cannot read —
-          // is still diagnosable from the client via /runs/active. Best-effort:
-          // the import + every record call is wrapped so diagnostics can never
-          // break the worker path.
-          const diag = await import("../agent/run-store.js")
-            .then((m) => ({
-              record: m.recordRunDiagnostic,
-              stages: m.RUN_DIAG_STAGE,
-            }))
-            .catch(() => null);
 
           // Consume the body ONCE (h3 v2's web Request stream is single-use).
           let processBody: any;
@@ -8015,18 +8004,6 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             return { error: "Invalid request body" };
           }
 
-          // Record "the route handler was entered" against the run BEFORE auth
-          // runs. This is the proof the bg-fn invocation actually reached Nitro
-          // (vs. dying at the function entry / never being invoked). The runId
-          // is parsed without authenticating so we can attach it even on a
-          // subsequent auth failure.
-          const diagRunId = extractProcessRunId(processBody);
-          if (diag && diagRunId) {
-            await diag
-              .record(diagRunId, diag.stages.routeEntered)
-              .catch(() => {});
-          }
-
           // Validate + HMAC-authenticate the self-dispatch and prepare the
           // background-worker body. Pure decision (unit-tested in
           // durable-background.spec.ts); the route only wires it to h3.
@@ -8041,6 +8018,12 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             // bypassing session auth) inside the unreadable bg function would
             // leave the run to time out with NO clue. The detail carries the
             // status + whether A2A_SECRET is even present in this isolate.
+            const diag = await import("../agent/run-store.js")
+              .then((m) => ({
+                record: m.recordRunDiagnostic,
+                stages: m.RUN_DIAG_STAGE,
+              }))
+              .catch(() => null);
             if (diag && prepared.runId) {
               const a2aPresent = Boolean(
                 process.env.A2A_SECRET && process.env.A2A_SECRET.length > 0,
@@ -8057,27 +8040,58 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             return { error: prepared.error };
           }
 
-          // DIAGNOSTIC: auth + body validation passed. Reaching here proves the
-          // request was authenticated and we are about to invoke the worker.
-          if (diag) {
-            await diag
-              .record(prepared.runId, diag.stages.authPassed)
-              .catch(() => {});
+          const preparedMarker = (prepared.body as Record<string, unknown>)[
+            AGENT_CHAT_BACKGROUND_RUN_FIELD
+          ];
+          const expectsBackgroundRuntime =
+            backgroundRunMarkerExpectsBackgroundRuntime(preparedMarker);
+          const runtimeGlobals = globalThis as Record<string, unknown>;
+          const hadExpectedRuntimeMarker = Object.prototype.hasOwnProperty.call(
+            runtimeGlobals,
+            "__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__",
+          );
+          const previousExpectedRuntimeMarker =
+            runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__;
+          if (expectsBackgroundRuntime) {
+            runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ = true;
           }
 
-          // Stash the verified+augmented body for the handler — the body stream
-          // is already consumed, so the handler reads this instead.
-          (event as any).context = (event as any).context ?? {};
-          (event as any).context.__agentChatBackgroundBody = prepared.body;
-
-          // Durable owner context: this self-dispatch is cookieless (HMAC-only).
-          // Resolve the owner from the persisted run row, never the request body,
-          // then invoke the normal handler. The shared agent-run context helper
-          // expands that owner into the same user/org AsyncLocalStorage context the
-          // foreground request uses, so credential and data scoping stay aligned.
-          await seedBackgroundAgentRunOwnerContext(event, prepared.runId);
-
           try {
+            // DIAGNOSTIC: load the run-store diagnostic recorder only after the
+            // authenticated marker has been mirrored into globalThis. run-store
+            // can initialize the DB pool; the pool must see the same background
+            // proof as the agent timeout logic before that happens.
+            const diag = await import("../agent/run-store.js")
+              .then((m) => ({
+                record: m.recordRunDiagnostic,
+                stages: m.RUN_DIAG_STAGE,
+              }))
+              .catch(() => null);
+
+            // Record "the route handler was entered" against the run after auth
+            // succeeds. This is the proof the bg-fn invocation actually reached
+            // Nitro (vs. dying at the function entry / never being invoked).
+            if (diag) {
+              await diag
+                .record(prepared.runId, diag.stages.routeEntered)
+                .catch(() => {});
+              await diag
+                .record(prepared.runId, diag.stages.authPassed)
+                .catch(() => {});
+            }
+
+            // Stash the verified+augmented body for the handler — the body stream
+            // is already consumed, so the handler reads this instead.
+            (event as any).context = (event as any).context ?? {};
+            (event as any).context.__agentChatBackgroundBody = prepared.body;
+
+            // Durable owner context: this self-dispatch is cookieless (HMAC-only).
+            // Resolve the owner from the persisted run row, never the request
+            // body, then invoke the normal handler. The shared agent-run context
+            // helper expands that owner into the same user/org AsyncLocalStorage
+            // context the foreground request uses, so credential and data scoping
+            // stay aligned.
+            await seedBackgroundAgentRunOwnerContext(event, prepared.runId);
             return await invokeAgentChatHandler(event);
           } catch (err: any) {
             console.error("[agent-chat] _process-run failed:", err);
@@ -8099,6 +8113,18 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             );
             setResponseStatus(event, 500);
             return { error: "process-run failed" };
+          } finally {
+            if (expectsBackgroundRuntime) {
+              if (hadExpectedRuntimeMarker) {
+                runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ =
+                  previousExpectedRuntimeMarker;
+              } else {
+                Reflect.deleteProperty(
+                  runtimeGlobals,
+                  "__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__",
+                );
+              }
+            }
           }
         }),
       );

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/DashboardFilterBar.tsx

@@ -228,18 +228,25 @@ export function DashboardFilterBar({
       <Collapsible
         open={filtersOpen}
         onOpenChange={setFiltersOpen}
-        className="group rounded-lg border border-border bg-card p-3"
+        className="group rounded-lg border border-border bg-card px-3 py-2"
       >
-        <div className="flex items-center justify-between gap-3">
-          <div className="flex items-baseline gap-2">
-            <h3 className="text-xs font-semibold text-muted-foreground uppercase tracking-wider">
-              {t("sqlDashboard.filters")}
-            </h3>
-            <span className="text-[10px] text-muted-foreground/60">
-              {t("sqlDashboard.autoApplied")}
-            </span>
-          </div>
-          <div className="flex items-center gap-1 opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100 group-data-[state=closed]:opacity-100">
+        <div className="flex flex-wrap items-end justify-between gap-3">
+          <CollapsibleContent className="min-w-0 flex-1">
+            <div className="flex flex-wrap gap-3 items-end">
+              {uniqueFilters.map((f) => (
+                <FilterControl
+                  key={f.id}
+                  filter={f}
+                  vars={vars}
+                  hasParam={(key) =>
+                    searchParams.has(FILTER_PARAM_PREFIX + key)
+                  }
+                  setValue={(updates) => setParam(updates)}
+                />
+              ))}
+            </div>
+          </CollapsibleContent>
+          <div className="flex shrink-0 items-center gap-1 self-center opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100 group-data-[state=closed]:opacity-100">
             {onSaveView && filtersActive && (
               <Button
                 variant="ghost"
@@ -284,19 +291,6 @@ export function DashboardFilterBar({
             </CollapsibleTrigger>
           </div>
         </div>
-        <CollapsibleContent className="pt-3">
-          <div className="flex flex-wrap gap-3 items-end">
-            {uniqueFilters.map((f) => (
-              <FilterControl
-                key={f.id}
-                filter={f}
-                vars={vars}
-                hasParam={(key) => searchParams.has(FILTER_PARAM_PREFIX + key)}
-                setValue={(updates) => setParam(updates)}
-              />
-            ))}
-          </div>
-        </CollapsibleContent>
       </Collapsible>
 
       <Dialog open={saveDialogOpen} onOpenChange={setSaveDialogOpen}>

package/corpus/templates/analytics/changelog/2026-07-01-dashboard-charts-no-longer-show-future-dates-when-clients-se.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Dashboard charts no longer show future dates when clients send bad event timestamps.

package/corpus/templates/analytics/changelog/2026-07-01-dashboard-filters-take-less-space-and-keep-view-actions-tucked.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-01
+---
+
+Dashboard filters take less space and keep view actions tucked to the side.

package/corpus/templates/analytics/server/lib/first-party-analytics.ts

@@ -50,6 +50,10 @@ function nowIso(): string {
   return new Date().toISOString();
 }
 
+function todayIsoDate(): string {
+  return nowIso().slice(0, 10);
+}
+
 function randomHex(bytes: number): string {
   const arr = new Uint8Array(bytes);
   if (!globalThis.crypto?.getRandomValues) {
@@ -204,17 +208,30 @@ function asString(value: unknown): string | null {
   return null;
 }
 
-function normalizeTimestamp(value: unknown): string {
-  if (value instanceof Date) return value.toISOString();
+export function normalizeAnalyticsTimestamp(
+  value: unknown,
+  receivedAt = nowIso(),
+): string {
+  const fallback = (() => {
+    const date = new Date(receivedAt);
+    return Number.isNaN(date.getTime()) ? nowIso() : date.toISOString();
+  })();
+  const fallbackTime = new Date(fallback).getTime();
+  const normalize = (date: Date) => {
+    if (Number.isNaN(date.getTime())) return fallback;
+    return date.getTime() > fallbackTime ? fallback : date.toISOString();
+  };
+
+  if (value instanceof Date) return normalize(value);
   if (typeof value === "number") {
     const d = new Date(value);
-    return Number.isNaN(d.getTime()) ? nowIso() : d.toISOString();
+    return normalize(d);
   }
   if (typeof value === "string" && value.trim()) {
     const d = new Date(value);
-    return Number.isNaN(d.getTime()) ? nowIso() : d.toISOString();
+    return normalize(d);
   }
-  return nowIso();
+  return fallback;
 }
 
 function eventDateFromTimestamp(timestamp: string): string {
@@ -362,7 +379,7 @@ export async function recordAnalyticsEvents(
       asString((properties as any).anonymousId) ??
       asString((properties as any).distinctId);
     const userKey = userId || anonymousId;
-    const timestamp = normalizeTimestamp(event.timestamp);
+    const timestamp = normalizeAnalyticsTimestamp(event.timestamp, receivedAt);
 
     return {
       id: id("evt"),
@@ -516,9 +533,17 @@ function scopeClause(scope: AnalyticsScope): {
   };
 }
 
-function scopedAnalyticsSql(
+function freshnessClause(tableName: string): string {
+  if (tableName === "analytics_events") {
+    return "(COALESCE(NULLIF(event_date, ''), substr(timestamp, 1, 10)) <= ?)";
+  }
+  return "(substr(started_at, 1, 10) <= ?)";
+}
+
+export function scopedAnalyticsSql(
   sql: string,
   scope: AnalyticsScope,
+  today = todayIsoDate(),
 ): { sql: string; args: Array<string | null> } {
   const args: Array<string | null> = [];
   const aliasRe =
@@ -536,8 +561,8 @@ function scopedAnalyticsSql(
           ? aliasPart
           : ` AS ${normalizedTable}`;
       const scopeDef = scopeClause(scope);
-      args.push(...scopeDef.args);
-      return `${keyword} (SELECT * FROM ${normalizedTable} WHERE ${scopeDef.sql})${usableAlias}`;
+      args.push(...scopeDef.args, today);
+      return `${keyword} (SELECT * FROM ${normalizedTable} WHERE ${scopeDef.sql} AND ${freshnessClause(normalizedTable)})${usableAlias}`;
     },
   );
   return { sql: rewritten, args };

package/corpus/templates/analytics/server/lib/first-party-metric-catalog.ts

@@ -128,6 +128,10 @@ function daysAgoSql(days: number): string {
   return `to_char(CURRENT_DATE - INTERVAL '${days} ${unit}', 'YYYY-MM-DD')`;
 }
 
+function todaySql(): string {
+  return "to_char(CURRENT_DATE, 'YYYY-MM-DD')";
+}
+
 function windowStartFilter(days: number): string {
   return `${EVENT_DATE_SQL} >= ${daysAgoSql(days)}`;
 }
@@ -140,14 +144,14 @@ function rollingWindowStartSql(
 }
 
 function dashboardTimeRangeFilter(dateExpr = EVENT_DATE_FILTER_SQL): string {
-  return `('{{timeRange}}' IN ('', 'all') OR ('{{timeRange}}' = '7d' AND ${dateExpr} >= ${daysAgoSql(7)}) OR ('{{timeRange}}' = '30d' AND ${dateExpr} >= ${daysAgoSql(30)}) OR ('{{timeRange}}' = '90d' AND ${dateExpr} >= ${daysAgoSql(90)}) OR ('{{timeRange}}' = '180d' AND ${dateExpr} >= ${daysAgoSql(180)}) OR ('{{timeRange}}' = '365d' AND ${dateExpr} >= ${daysAgoSql(365)}))`;
+  return `(${dateExpr} <= ${todaySql()} AND ('{{timeRange}}' IN ('', 'all') OR ('{{timeRange}}' = '7d' AND ${dateExpr} >= ${daysAgoSql(7)}) OR ('{{timeRange}}' = '30d' AND ${dateExpr} >= ${daysAgoSql(30)}) OR ('{{timeRange}}' = '90d' AND ${dateExpr} >= ${daysAgoSql(90)}) OR ('{{timeRange}}' = '180d' AND ${dateExpr} >= ${daysAgoSql(180)}) OR ('{{timeRange}}' = '365d' AND ${dateExpr} >= ${daysAgoSql(365)})))`;
 }
 
 function dashboardLookbackTimeRangeFilter(
   dateExpr = EVENT_DATE_FILTER_SQL,
   lookbackDays = 0,
 ): string {
-  return `('{{timeRange}}' IN ('', 'all') OR ('{{timeRange}}' = '7d' AND ${dateExpr} >= ${daysAgoSql(7 + lookbackDays)}) OR ('{{timeRange}}' = '30d' AND ${dateExpr} >= ${daysAgoSql(30 + lookbackDays)}) OR ('{{timeRange}}' = '90d' AND ${dateExpr} >= ${daysAgoSql(90 + lookbackDays)}) OR ('{{timeRange}}' = '180d' AND ${dateExpr} >= ${daysAgoSql(180 + lookbackDays)}) OR ('{{timeRange}}' = '365d' AND ${dateExpr} >= ${daysAgoSql(365 + lookbackDays)}))`;
+  return `(${dateExpr} <= ${todaySql()} AND ('{{timeRange}}' IN ('', 'all') OR ('{{timeRange}}' = '7d' AND ${dateExpr} >= ${daysAgoSql(7 + lookbackDays)}) OR ('{{timeRange}}' = '30d' AND ${dateExpr} >= ${daysAgoSql(30 + lookbackDays)}) OR ('{{timeRange}}' = '90d' AND ${dateExpr} >= ${daysAgoSql(90 + lookbackDays)}) OR ('{{timeRange}}' = '180d' AND ${dateExpr} >= ${daysAgoSql(180 + lookbackDays)}) OR ('{{timeRange}}' = '365d' AND ${dateExpr} >= ${daysAgoSql(365 + lookbackDays)})))`;
 }
 
 const DASHBOARD_TIME_RANGE_FILTER = dashboardTimeRangeFilter();