@agent-native/core 0.90.4 → 0.90.7

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

@@ -175,15 +175,16 @@ export function RunStuckBanner({
   }
   const ownerId = autoRetryOwnerId ?? generatedOwnerIdRef.current;
   const backgroundWorkerStillAlive = isFreshBackgroundWorker(state);
-  // Background-dispatched runs are recovered by the SERVER (chained
-  // continuation chunks + lost-handoff sweep); an automatic client abort
-  // would kill a live server-chained run. Auto-retry is therefore disabled
-  // unconditionally for ANY background dispatch mode — not just a
-  // fresh-heartbeat worker — and the localStorage/Web-Locks auto-retry claim
-  // below is never taken for these runs (the adapter's follow loop is
-  // read-only, so multiple tabs need no retry dedup). Only the manual banner
-  // remains, on the wider background threshold from useRunStuckDetection.
-  const isBackgroundDispatch =
+  // Server-continued runs are recovered by the SERVER (chained continuation
+  // chunks + lost-handoff sweep); an automatic client abort would kill a live
+  // server-chained run. Auto-retry is therefore disabled unconditionally for
+  // these modes — not just a fresh-heartbeat worker — and the
+  // localStorage/Web-Locks auto-retry claim below is never taken for them (the
+  // adapter's follow loop is read-only, so multiple tabs need no retry dedup).
+  // Only the manual banner remains, on the wider server-owned threshold from
+  // useRunStuckDetection.
+  const isServerContinuedDispatch =
+    state.dispatchMode === "foreground-self-chain" ||
     state.dispatchMode?.startsWith("background") === true;
 
   const lastReportedRef = useRef<{
@@ -224,9 +225,9 @@ export function RunStuckBanner({
   useEffect(() => {
     if (
       !autoRetry ||
-      // Server owns recovery for background dispatch modes — never auto-abort
-      // (see comment on isBackgroundDispatch above).
-      isBackgroundDispatch ||
+      // Server owns recovery for these dispatch modes — never auto-abort (see
+      // comment on isServerContinuedDispatch above).
+      isServerContinuedDispatch ||
       backgroundWorkerStillAlive ||
       !state.isStuck ||
       !state.runId ||
@@ -263,7 +264,7 @@ export function RunStuckBanner({
     autoRetry,
     backgroundWorkerStillAlive,
     busy,
-    isBackgroundDispatch,
+    isServerContinuedDispatch,
     onRetry,
     ownerId,
     state.isStuck,

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

@@ -133,16 +133,15 @@ const MAX_HISTORY_LARGE_TOOL_ARGS_CHARS = 200_000;
 const STARTUP_RESPONSE_TIMEOUT_MS = 45_000;
 
 // ── Background follow mode ──────────────────────────────────────────────────
-// For background-dispatched runs (dispatchMode starts with "background") the
-// SERVER is the sole recovery brain: it chains continuation chunks itself
-// (fresh runId, same turnId), pre-inserts the successor run row BEFORE the old
-// chunk completes (so /runs/active shows an active run continuously across
-// chunk boundaries), and a server sweep reaps lost handoffs into loud terminal
-// errors. The client therefore never POSTs synthetic continuations for these
-// runs — it demotes itself to a READER of server state: poll /runs/active,
-// (re)attach to whichever run of this turn is live, and fold its events into
-// the same assistant message. Read-only, so multiple tabs following the same
-// run are safe (no localStorage/Web-Locks claim needed).
+// For server-continued runs (dispatchMode starts with "background" or equals
+// "foreground-self-chain") the SERVER normally chains continuation chunks
+// itself (fresh runId, same turnId), pre-inserts the successor run row BEFORE
+// the old chunk completes (so /runs/active shows an active run continuously
+// across chunk boundaries), and a server sweep reaps lost handoffs into loud
+// terminal errors. The client demotes itself to a READER of server state for
+// healthy handoffs. Foreground self-chain keeps one escape hatch: if the server
+// reports that the self-dispatch itself failed before a successor claimed the
+// run, the existing client auto-continue POST remains the fallback.
 const BACKGROUND_FOLLOW_POLL_INTERVAL_MS = 1_000;
 // How long the follow loop tolerates seeing NO active run for this turn before
 // treating the turn as ended. The server pre-inserts the successor row before
@@ -1687,12 +1686,24 @@ export function createAgentChatAdapter(
         if (mode) currentRunDispatchMode = mode;
       };
 
-      // Mode switch for recovery ownership: background-dispatched runs are
-      // recovered by the SERVER (chained continuations, sweeps); the client
-      // only follows. Foreground (null/"foreground"/unknown) keeps the full
-      // client-side continuation machinery unchanged.
-      const isBackgroundDispatch = () =>
+      // Mode switch for recovery ownership: durable/background-dispatched runs
+      // are always recovered by the server. Foreground self-chain follows the
+      // server on healthy handoffs, but a loud self-dispatch failure falls back
+      // to the client POST path because no successor run owns recovery yet.
+      const isDurableBackgroundDispatch = () =>
         currentRunDispatchMode?.startsWith("background") === true;
+      const isForegroundSelfChainDispatch = () =>
+        currentRunDispatchMode === "foreground-self-chain";
+      const shouldFollowServerContinuation = (
+        signal?: AgentAutoContinueSignal,
+      ) => {
+        if (isDurableBackgroundDispatch()) return true;
+        if (!isForegroundSelfChainDispatch()) return false;
+        return (
+          signal?.errorInfo?.errorCode !==
+          "background_continuation_dispatch_failed"
+        );
+      };
 
       const rememberRunSeq = (seq: number) => {
         lastSeq = seq;
@@ -2966,7 +2977,7 @@ export function createAgentChatAdapter(
               // following of server state instead. This is the fix for the
               // client/server recovery race: client watchdog signals here are
               // just "reattach", not "recover".
-              if (isBackgroundDispatch() && threadId) {
+              if (shouldFollowServerContinuation(err) && threadId) {
                 yield* followBackgroundTurn(err);
                 return;
               }
@@ -3145,7 +3156,7 @@ export function createAgentChatAdapter(
             // synthetic-continuation POST below. (An initial POST that failed
             // before any response headers arrived has no dispatch mode yet
             // and keeps the foreground startup-retry path.)
-            if (isBackgroundDispatch() && threadId) {
+            if (shouldFollowServerContinuation() && threadId) {
               yield* followBackgroundTurn(
                 new AgentAutoContinueSignal({ reason: "stream_ended" }),
               );

package/corpus/core/src/client/use-db-sync.ts

@@ -22,6 +22,13 @@ interface QueryClient {
 const POLL_ABORT_MIN_MS = 10_000;
 const SSE_FALLBACK_INTERVAL_MS = 15_000;
 const POLL_AUTH_FAILURE_COOLDOWN_MS = 60_000;
+/**
+ * Max cadence for SSE/poll-driven query invalidation in `useDbSync`. Events
+ * that arrive within this window of the first one in a burst are merged into
+ * a single `invalidateForEvents` call instead of one call per event — see the
+ * `queueInvalidateBatch` comment at the call site.
+ */
+const INVALIDATE_COALESCE_MS = 250;
 
 class HttpStatusError extends Error {
   status: number;
@@ -94,6 +101,46 @@ function isAuthFailure(error: unknown): boolean {
   );
 }
 
+/**
+ * App-state keys that drive immediate UI navigation/interaction and must
+ * never sit behind the invalidation coalesce window (see
+ * `isInteractionCriticalSyncEvent`).
+ */
+const INTERACTION_CRITICAL_APP_STATE_KEYS = [
+  "navigate",
+  "show-questions",
+  "__set_url__",
+];
+
+/**
+ * True for sync events that drive immediate, agent-initiated UI navigation
+ * or interaction rather than passive data invalidation — app-state writes in
+ * general (they back `["app-state"]` queries directly), and specifically the
+ * `navigate` / `show-questions` / `__set_url__` app-state keys that
+ * `invalidateForEvents` special-cases into their own query keys below.
+ *
+ * `useDbSync` batches ordinary invalidation-driving events (action/collab/db
+ * change events) into one flush per `INVALIDATE_COALESCE_MS` so a chatty doc
+ * doesn't refetch on every keystroke. That trade-off is wrong for these
+ * events: agent-driven navigation, `set-url`, and guided-questions prompts
+ * must land as close to instantly as possible, so any batch containing one
+ * of these bypasses the coalesce window and flushes immediately instead.
+ *
+ * Exported as a small pure predicate so this classification is unit-testable
+ * independent of the transport/timer plumbing around it.
+ */
+export function isInteractionCriticalSyncEvent(event: SyncEvent): boolean {
+  return (
+    event.source === "app-state" &&
+    (event.key === "*" ||
+      INTERACTION_CRITICAL_APP_STATE_KEYS.some(
+        (key) =>
+          event.key === key ||
+          (typeof event.key === "string" && event.key.startsWith(`${key}:`)),
+      ))
+  );
+}
+
 async function fetchPollJson<T>(
   pollUrl: string,
   since: number,
@@ -615,6 +662,51 @@ export function useDbSync(
     // processed by THIS subscriber so stale poll re-deliveries are ignored.
     let subscriberVersion = 0;
 
+    // Coalesce bursts of SSE-driven invalidation into at most one flush per
+    // INVALIDATE_COALESCE_MS. A chatty doc (many small agent edits, several
+    // peers editing at once) can otherwise deliver a handful of `action`/
+    // `collab` events within a few hundred ms, each independently calling
+    // `queryClient.invalidateQueries` and firing `onEvent` — every one of
+    // those touches whatever query subscribers are mounted (e.g. a
+    // full-page editor) even though the end state only needs to be
+    // refreshed once. Version bookkeeping stays synchronous (below) so
+    // freshness filtering for the NEXT batch is unaffected by the delay.
+    //
+    // This coalesce window is wrong for interaction-critical events (agent
+    // navigation, `set-url`, guided questions — see
+    // `isInteractionCriticalSyncEvent`): those must reach the UI immediately,
+    // not up to INVALIDATE_COALESCE_MS late. So a fresh batch containing one
+    // of those flushes synchronously (queued + new events together,
+    // canceling any pending timer) instead of joining the coalesce window.
+    // Pure invalidation bursts with no interaction-critical members keep the
+    // coalesced behavior.
+    let pendingInvalidateEvents: SyncEvent[] = [];
+    let invalidateTimer: ReturnType<typeof setTimeout> | null = null;
+
+    function flushInvalidateBatch() {
+      if (invalidateTimer) {
+        clearTimeout(invalidateTimer);
+        invalidateTimer = null;
+      }
+      if (pendingInvalidateEvents.length === 0) return;
+      const batch = pendingInvalidateEvents;
+      pendingInvalidateEvents = [];
+      invalidateForEvents(batch);
+    }
+
+    function queueInvalidateBatch(events: SyncEvent[]) {
+      pendingInvalidateEvents.push(...events);
+      if (events.some(isInteractionCriticalSyncEvent)) {
+        flushInvalidateBatch();
+        return;
+      }
+      if (invalidateTimer) return;
+      invalidateTimer = setTimeout(
+        flushInvalidateBatch,
+        INVALIDATE_COALESCE_MS,
+      );
+    }
+
     function hasAppStateEvent(events: SyncEvent[], key: string): boolean {
       return events.some(
         (event) =>
@@ -722,7 +814,7 @@ export function useDbSync(
       });
 
       if (freshEvents.length > 0) {
-        invalidateForEvents(freshEvents);
+        queueInvalidateBatch(freshEvents);
       }
 
       const maxEventVersion = freshEvents.reduce(
@@ -746,6 +838,12 @@ export function useDbSync(
     });
 
     return () => {
+      if (invalidateTimer) {
+        clearTimeout(invalidateTimer);
+        // Flush synchronously on unmount so a pending batch isn't silently
+        // dropped (e.g. a route change right after an agent edit lands).
+        flushInvalidateBatch();
+      }
       transport.remove(id);
       // If the registry still holds this transport, and the transport is now
       // empty, evict it so the next mount gets a fresh instance rather than a

package/corpus/core/src/client/use-run-stuck-detection.ts

@@ -26,7 +26,7 @@ export interface RunStuckState {
   heartbeatAt: number | null;
   /** Milliseconds since `heartbeatAt`, computed against the server clock. */
   heartbeatSinceMs: number | null;
-  /** How the run was dispatched, e.g. foreground or background-processing. */
+  /** How the run was dispatched/continued, e.g. foreground-self-chain or background-processing. */
   dispatchMode: string | null;
 }
 
@@ -133,10 +133,13 @@ export function useRunStuckDetection({
             heartbeatAt != null ? nowMs - heartbeatAt : null;
           const dispatchMode =
             typeof data.dispatchMode === "string" ? data.dispatchMode : null;
-          // Background-dispatched runs get the wider threshold: the server's
-          // own recovery (150s no-progress backstop + chained continuations)
-          // must get its chance before the user sees a "stuck" affordance.
-          const effectiveThresholdMs = dispatchMode?.startsWith("background")
+          // Server-continued runs get the wider threshold: the server's own
+          // recovery (150s no-progress backstop + chained continuations) must
+          // get its chance before the user sees a "stuck" affordance.
+          const serverContinued =
+            dispatchMode === "foreground-self-chain" ||
+            dispatchMode?.startsWith("background") === true;
+          const effectiveThresholdMs = serverContinued
             ? backgroundStuckThresholdMs
             : stuckThresholdMs;
           const isStuck = Boolean(

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

@@ -94,6 +94,31 @@ function isDocumentHidden(): boolean {
   );
 }
 
+/**
+ * Content equality for deduped active-user lists. `dedupeCollabUsersByEmail`
+ * always allocates a fresh array (and fresh per-user objects), so callers
+ * that only want to know "did the actual user set change" need this instead
+ * of an identity check. Order-sensitive: the dedupe helper iterates awareness
+ * states in a stable Map insertion order, so a reordering here does reflect
+ * a real change (a client joined/left and re-joined).
+ */
+function collabUsersEqual(a: CollabUser[], b: CollabUser[]): boolean {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const left = a[i]!;
+    const right = b[i]!;
+    if (
+      left.email !== right.email ||
+      left.name !== right.name ||
+      left.color !== right.color
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
 /**
  * Leader election for applying authoritative external snapshots into a shared
  * collaborative document.
@@ -566,10 +591,30 @@ class CollabDocConnection {
         }
       }
     });
-    this.setSnapshot({
-      activeUsers: dedupeCollabUsersByEmail(users),
-      agentPresent: hasAgent,
-    });
+    const nextActiveUsers = dedupeCollabUsersByEmail(users);
+    // Awareness "change" fires for every remote broadcast — including cursor
+    // jiggles, re-published-but-unchanged heartbeat state, and edits to
+    // presence fields (recentEdits, selection) that don't affect who's
+    // active. dedupeCollabUsersByEmail always returns a fresh array, so
+    // without this comparison every one of those events would hand
+    // `activeUsers` a new identity and force every consumer (e.g. a
+    // full-page editor keying a useMemo/effect off it) to re-render even
+    // though the actual user list is unchanged. Reuse the previous
+    // reference when the deduped content is the same, matching the
+    // stable-ref discipline `usePresence`'s shallowEqualOthers already
+    // applies to `others`.
+    const activeUsers = collabUsersEqual(
+      this.snapshot.activeUsers,
+      nextActiveUsers,
+    )
+      ? this.snapshot.activeUsers
+      : nextActiveUsers;
+    if (
+      activeUsers !== this.snapshot.activeUsers ||
+      hasAgent !== this.snapshot.agentPresent
+    ) {
+      this.setSnapshot({ activeUsers, agentPresent: hasAgent });
+    }
 
     // Fast awareness push: whenever awareness changes (e.g. cursor moves,
     // setPresence() calls), schedule a throttled POST so peers receive updates

package/corpus/core/src/deploy/build.ts

@@ -2427,6 +2427,105 @@ export const config = {
   );
 }
 
+export function assertSingleTemplateNetlifyBuildOutput(
+  projectCwd: string,
+): void {
+  const failures: string[] = [];
+  const publishDir = path.join(projectCwd, "dist");
+  const internalDir = path.join(projectCwd, ".netlify", "functions-internal");
+  const serverDir = path.join(internalDir, "server");
+  const serverEntryPath = path.join(serverDir, "server.mjs");
+  const serverMainPath = path.join(serverDir, "main.mjs");
+
+  if (!fs.existsSync(publishDir)) {
+    failures.push("missing publish directory: dist");
+  }
+
+  if (!fs.existsSync(serverDir)) {
+    failures.push(
+      "missing scanned Netlify server function: .netlify/functions-internal/server",
+    );
+  }
+
+  if (!fs.existsSync(serverMainPath)) {
+    failures.push(
+      "missing Netlify server bundle: .netlify/functions-internal/server/main.mjs",
+    );
+  }
+
+  if (!fs.existsSync(serverEntryPath)) {
+    failures.push(
+      "missing Netlify server entry: .netlify/functions-internal/server/server.mjs",
+    );
+  } else {
+    const serverEntry = fs.readFileSync(serverEntryPath, "utf-8");
+    if (!/\bpath\s*:\s*["']\/\*["']/.test(serverEntry)) {
+      failures.push(
+        'Netlify server entry is missing the "/*" catch-all function path',
+      );
+    }
+    if (!serverEntry.includes('"/.netlify/*"')) {
+      failures.push(
+        'Netlify server catch-all is missing the "/.netlify/*" exclusion',
+      );
+    }
+    if (!serverEntry.includes("./main.mjs")) {
+      failures.push(
+        "Netlify server entry does not reference the generated main.mjs bundle",
+      );
+    }
+  }
+
+  if (isDurableBackgroundDeployEnabled()) {
+    const backgroundDir = path.join(
+      internalDir,
+      AGENT_BACKGROUND_FUNCTION_NAME,
+    );
+    const backgroundEntryPath = path.join(
+      backgroundDir,
+      `${AGENT_BACKGROUND_FUNCTION_NAME}.mjs`,
+    );
+    if (!fs.existsSync(backgroundEntryPath)) {
+      failures.push(
+        `durable background is enabled but ${path.relative(
+          projectCwd,
+          backgroundEntryPath,
+        )} was not emitted`,
+      );
+    } else {
+      const backgroundEntry = fs.readFileSync(backgroundEntryPath, "utf-8");
+      if (!/\bbackground\s*:\s*true\b/.test(backgroundEntry)) {
+        failures.push(
+          `durable background entry ${path.relative(
+            projectCwd,
+            backgroundEntryPath,
+          )} is missing background: true`,
+        );
+      }
+      if (/^\s*path\s*:/m.test(backgroundEntry)) {
+        failures.push(
+          `durable background entry ${path.relative(
+            projectCwd,
+            backgroundEntryPath,
+          )} must not declare a custom path`,
+        );
+      }
+    }
+  }
+
+  if (failures.length > 0) {
+    throw new Error(
+      "[deploy] Netlify deploy guard failed; refusing to publish an output " +
+        "that would likely serve Netlify 404s:\n" +
+        failures.map((failure) => `- ${failure}`).join("\n"),
+    );
+  }
+
+  console.log(
+    "[deploy] Netlify deploy guard passed: publish dir and catch-all server function are present.",
+  );
+}
+
 function copyInstalledLibsqlNativePackages(serverDir: string | undefined) {
   if (!serverDir || !fs.existsSync(serverDir)) return;
   const nodeModulesRoots = nodeModulesAncestors(cwd);
@@ -2976,6 +3075,10 @@ export default bundle;
     }
   }
 
+  if (preset === "netlify") {
+    assertSingleTemplateNetlifyBuildOutput(cwd);
+  }
+
   // Resolve remaining bare npm imports by bundling them into _libs/.
   // Nitro sometimes leaves small packages as externals even with noExternals.
   if (preset.startsWith("cloudflare") || preset.startsWith("deno")) {

package/corpus/core/src/server/core-routes-plugin.ts

@@ -8,6 +8,7 @@ import {
   setCookie,
   deleteCookie,
   getRequestURL,
+  getRequestIP,
 } from "h3";
 import type { H3Event } from "h3";
 import { readMultipartFormData } from "h3";
@@ -285,9 +286,16 @@ const BUILDER_WAITLIST_DEFAULT_USE_CASE = "builder_agent_background_coding";
 const BUILDER_WAITLIST_USE_CASES = new Set([
   BUILDER_WAITLIST_DEFAULT_USE_CASE,
   "design_publish_app",
+  "docs_build_online_waitlist",
 ]);
 const BUILDER_WAITLIST_FORM_TIMEOUT_MS = 8000;
 const BUILDER_WAITLIST_TEXT_LIMIT = 4000;
+const BUILDER_WAITLIST_RATE_LIMIT_WINDOW_MS = 60_000;
+const BUILDER_WAITLIST_RATE_LIMIT_MAX = 5;
+const builderWaitlistRateLimitHits = new Map<
+  string,
+  { count: number; resetAt: number }
+>();
 
 interface BuilderWaitlistFormTarget {
   formId: string;
@@ -295,6 +303,7 @@ interface BuilderWaitlistFormTarget {
 }
 
 export interface BuilderWaitlistBody {
+  email?: unknown;
   prompt?: unknown;
   orgName?: unknown;
   appUrl?: unknown;
@@ -332,6 +341,106 @@ function normalizeBuilderWaitlistUseCase(value: unknown): string {
     : BUILDER_WAITLIST_DEFAULT_USE_CASE;
 }
 
+function isValidWaitlistEmail(email: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+
+export function isAnonymousWaitlistSessionEmail(email: string): boolean {
+  return email.startsWith("anon-") && email.endsWith("@agent-native.com");
+}
+
+export function resolveWaitlistEmail(
+  sessionEmail: string | undefined,
+  bodyEmail: unknown,
+): string | null {
+  const provided = cleanBuilderWaitlistText(bodyEmail, 320);
+  if (provided && isValidWaitlistEmail(provided)) return provided;
+  if (sessionEmail && !isAnonymousWaitlistSessionEmail(sessionEmail)) {
+    return sessionEmail;
+  }
+  return null;
+}
+
+function normalizeWaitlistRateLimitPart(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+function getBuilderWaitlistClientIp(event: H3Event): string | undefined {
+  const trusted =
+    getHeader(event, "x-nf-client-connection-ip") ??
+    getHeader(event, "cf-connecting-ip") ??
+    getHeader(event, "true-client-ip") ??
+    getHeader(event, "x-real-ip");
+  if (trusted && trusted.trim()) return trusted.trim();
+
+  const forwardedFor = getHeader(event, "x-forwarded-for");
+  const forwardedClientIp = forwardedFor?.split(",")[0]?.trim();
+  if (forwardedClientIp) return forwardedClientIp;
+
+  try {
+    return getRequestIP(event) ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function getBuilderWaitlistRateLimitKeys(
+  event: H3Event,
+  email: string,
+): string[] {
+  const clientIp = getBuilderWaitlistClientIp(event);
+  return [
+    `email:${normalizeWaitlistRateLimitPart(email)}`,
+    `ip:${normalizeWaitlistRateLimitPart(clientIp ?? "unknown")}`,
+  ];
+}
+
+export function checkBuilderWaitlistRateLimit(
+  event: H3Event,
+  email: string,
+  now = Date.now(),
+): { ok: true } | { ok: false; retryAfterSeconds: number } {
+  const keys = getBuilderWaitlistRateLimitKeys(event, email);
+  let retryAfterMs = 0;
+
+  for (const key of keys) {
+    const entry = builderWaitlistRateLimitHits.get(key);
+    if (!entry) continue;
+    if (entry.resetAt <= now) {
+      builderWaitlistRateLimitHits.delete(key);
+      continue;
+    }
+    if (entry.count >= BUILDER_WAITLIST_RATE_LIMIT_MAX) {
+      retryAfterMs = Math.max(retryAfterMs, entry.resetAt - now);
+    }
+  }
+
+  if (retryAfterMs > 0) {
+    return {
+      ok: false,
+      retryAfterSeconds: Math.max(1, Math.ceil(retryAfterMs / 1000)),
+    };
+  }
+
+  for (const key of keys) {
+    const entry = builderWaitlistRateLimitHits.get(key);
+    if (!entry || entry.resetAt <= now) {
+      builderWaitlistRateLimitHits.set(key, {
+        count: 1,
+        resetAt: now + BUILDER_WAITLIST_RATE_LIMIT_WINDOW_MS,
+      });
+    } else {
+      entry.count += 1;
+    }
+  }
+
+  return { ok: true };
+}
+
+export function resetBuilderWaitlistRateLimitForTests() {
+  builderWaitlistRateLimitHits.clear();
+}
+
 function normalizeHttpOrigin(value: string): string | null {
   try {
     const url = new URL(value);
@@ -1869,15 +1978,35 @@ export function createCoreRoutesPlugin(
             return { error: "Method not allowed" };
           }
           const session = await getSession(event).catch(() => null);
-          if (!session?.email) {
-            setResponseStatus(event, 401);
-            return { error: "Authentication required" };
-          }
           const body = ((await readBody(event).catch(() => ({}))) ??
             {}) as BuilderWaitlistBody;
+          const waitlistEmail = resolveWaitlistEmail(
+            session?.email,
+            body.email,
+          );
+          if (!waitlistEmail) {
+            setResponseStatus(event, 400);
+            return { error: "Valid email required" };
+          }
+          const waitlistRateLimit = checkBuilderWaitlistRateLimit(
+            event,
+            waitlistEmail,
+          );
+          if (!waitlistRateLimit.ok) {
+            setResponseStatus(event, 429);
+            setResponseHeader(
+              event,
+              "Retry-After",
+              String(waitlistRateLimit.retryAfterSeconds),
+            );
+            return {
+              error:
+                "Too many waitlist requests. Please try again in a minute.",
+            };
+          }
           const waitlistPayload = buildBuilderWaitlistFormPayload(
             event,
-            session.email,
+            waitlistEmail,
             body,
           );
           const waitlistSource = waitlistPayload.data.source;
@@ -1886,14 +2015,14 @@ export function createCoreRoutesPlugin(
           try {
             formSubmission = await submitBuilderWaitlistForm(
               event,
-              session.email,
+              waitlistEmail,
               body,
             );
           } catch (err) {
             await trackBuilderLifecycle(
               event,
               "builder branch waitlist form failed",
-              session.email,
+              waitlistEmail,
               {
                 reason:
                   err instanceof Error ? err.message : "unknown_waitlist_error",
@@ -1911,7 +2040,7 @@ export function createCoreRoutesPlugin(
           await trackBuilderLifecycle(
             event,
             "builder branch waitlist joined",
-            session.email,
+            waitlistEmail,
             {
               formId: formSubmission.formId ?? null,
               formSubmitted: formSubmission.submitted,

package/corpus/templates/clips/changelog/2026-07-07-faster-local-whisper-dictation-start.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-07
+---
+
+Dictation starts faster when using Local Whisper after the first press.