@agent-native/core 0.84.65 → 0.84.67

package/corpus/README.md

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

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.84.67
+
+### Patch Changes
+
+- 171f6e6: Remove app document CSP headers so hosted Google Tag Manager and framework inline bootstrap scripts are not blocked or reported by a shared policy.
+
+## 0.84.66
+
+### Patch Changes
+
+- 70a6085: Keep hosted chat runs inside the active worker when a progress-aware action-preparation checkpoint asks to continue, instead of depending on the browser to start the recovery turn.
+
 ## 0.84.65
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.84.65",
+  "version": "0.84.67",
   "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": {

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

@@ -971,6 +971,12 @@ const TOOL_INPUT_ACTIVITY_INTERVAL_MS = 1500;
 const ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS = 90_000;
 const ACTION_PREPARATION_ZERO_BYTE_RESTART_LIMIT = 2;
 const MODEL_STREAM_NO_PROGRESS_TIMEOUT_MS = 90_000;
+const MAIN_CHAT_INTERNAL_CONTINUATION_LIMIT = 6;
+const RUN_BUDGET_EXHAUSTED_ERROR_CODE = "run_budget_exhausted";
+const RUN_BUDGET_EXHAUSTED_MESSAGE =
+  "I ran out of time before finishing this step. " +
+  "I stopped rather than keep retrying silently. " +
+  "Check any completed tool cards above before retrying, ideally as one smaller follow-up.";
 const MAX_TEXT_ATTACHMENT_CHARS = 60_000;
 const MAX_SELECTION_CONTEXT_CHARS = 8_000;
 const MAX_RESOURCE_INVENTORY_ITEMS = 40;
@@ -2978,7 +2984,7 @@ export async function runAgentLoop(opts: {
             };
           }
           return (
-            zeroByteToolInputRestart.count >
+            zeroByteToolInputRestart.count >=
               ACTION_PREPARATION_ZERO_BYTE_RESTART_LIMIT &&
             now - zeroByteToolInputRestart.firstStartedAt >=
               ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS
@@ -4430,6 +4436,82 @@ export function backgroundContinuationReasonForRun(
   return "run_timeout";
 }
 
+export async function runAgentLoopWithMainChatInternalContinuations(
+  opts: Parameters<typeof runAgentLoop>[0],
+): Promise<Awaited<ReturnType<typeof runAgentLoop>>> {
+  const usage: Awaited<ReturnType<typeof runAgentLoop>> = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    model: opts.model,
+  };
+  const addUsage = (next: Awaited<ReturnType<typeof runAgentLoop>>) => {
+    usage.inputTokens += next.inputTokens;
+    usage.outputTokens += next.outputTokens;
+    usage.cacheReadTokens += next.cacheReadTokens;
+    usage.cacheWriteTokens += next.cacheWriteTokens;
+    usage.model = next.model;
+  };
+
+  const localTurnEvents: AgentChatEvent[] = [];
+  let lastAttemptWasUnfinishedContinuation = false;
+  for (
+    let attempt = 0;
+    !opts.signal.aborted && attempt < MAIN_CHAT_INTERNAL_CONTINUATION_LIMIT;
+    attempt++
+  ) {
+    lastAttemptWasUnfinishedContinuation = false;
+    let continuationReason: AgentLoopContinuationReason | undefined;
+    const attemptStartIndex = localTurnEvents.length;
+    const send = (event: AgentChatEvent) => {
+      localTurnEvents.push(event);
+      if (
+        event.type === "auto_continue" &&
+        isAgentLoopContinuationReason(event.reason)
+      ) {
+        continuationReason = event.reason;
+        return;
+      }
+      opts.send(event);
+    };
+
+    const nextUsage = await runAgentLoop({ ...opts, send });
+    addUsage(nextUsage);
+
+    if (!continuationReason || opts.signal.aborted) {
+      return usage;
+    }
+
+    lastAttemptWasUnfinishedContinuation = true;
+    const attemptEvents = localTurnEvents.slice(attemptStartIndex);
+    const completedSideEffect = attemptEvents.some(
+      (event) =>
+        event.type === "tool_done" &&
+        event.completedSideEffect === true &&
+        event.isError !== true,
+    );
+    if (!completedSideEffect) {
+      opts.send({ type: "clear" });
+    }
+    const actionPreparationTool =
+      lastUnfinishedPreparingActionToolFromEvents(localTurnEvents);
+    appendAgentLoopContinuation(opts.messages, continuationReason, {
+      ...(actionPreparationTool ? { actionPreparationTool } : {}),
+    });
+  }
+
+  if (!opts.signal.aborted && lastAttemptWasUnfinishedContinuation) {
+    opts.send({
+      type: "error",
+      error: RUN_BUDGET_EXHAUSTED_MESSAGE,
+      errorCode: RUN_BUDGET_EXHAUSTED_ERROR_CODE,
+      recoverable: true,
+    });
+  }
+  return usage;
+}
+
 function endsAtContinuationBoundary(run: ActiveRun): boolean {
   return (
     endsAtInternalContinuationBoundary(run) ||
@@ -5770,6 +5852,11 @@ export function createProductionAgentHandler(
                     continuationDispatchPath,
                   );
                 try {
+                  await recordRunDiagnostic(
+                    run.runId,
+                    RUN_DIAG_STAGE.workerSetupStep,
+                    `chain_dispatch_start nextRunId=${nextRunId} reason=${continuationReason} path=${continuationDispatchPath}`,
+                  ).catch(() => {});
                   await fireInternalDispatch({
                     event,
                     // Continuation chunks use the same path resolution as the
@@ -5795,11 +5882,28 @@ export function createProductionAgentHandler(
                           continuationExpectsNetlifyBackgroundFunction,
                       },
                     },
+                    settleMs: continuationExpectsNetlifyBackgroundFunction
+                      ? BACKGROUND_CLAIM_GRACE_MS
+                      : undefined,
                   });
+                  await recordRunDiagnostic(
+                    run.runId,
+                    RUN_DIAG_STAGE.workerSetupStep,
+                    `chain_dispatch_sent nextRunId=${nextRunId} reason=${continuationReason}`,
+                  ).catch(() => {});
                 } catch (chainErr) {
                   // Chain dispatch failed — fail loud so the held row goes
                   // terminal instead of spinning. The reaper would also catch
                   // it, but this is immediate and truthful.
+                  await recordRunDiagnostic(
+                    run.runId,
+                    RUN_DIAG_STAGE.workerThrew,
+                    `chain_dispatch_failed nextRunId=${nextRunId} ${
+                      chainErr instanceof Error
+                        ? chainErr.message
+                        : String(chainErr)
+                    }`,
+                  ).catch(() => {});
                   console.error(
                     "[agent-chat] background continuation dispatch failed:",
                     chainErr instanceof Error ? chainErr.message : chainErr,
@@ -6242,7 +6346,7 @@ export function createProductionAgentHandler(
           if (obsConfig.enabled) {
             instrumented = true;
             loopUsage = await instrumentAgentLoop({
-              runAgentLoop,
+              runAgentLoop: runAgentLoopWithMainChatInternalContinuations,
               loopOpts: agentLoopOpts,
               runId,
               threadId: threadId ?? null,
@@ -6272,7 +6376,8 @@ export function createProductionAgentHandler(
           if (instrumented) throw err;
         }
         if (!instrumented) {
-          loopUsage = await runAgentLoop(agentLoopOpts);
+          loopUsage =
+            await runAgentLoopWithMainChatInternalContinuations(agentLoopOpts);
         }
 
         // Record token usage for cost monitoring so the Usage panel in

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

@@ -42,42 +42,9 @@ function getGaMeasurementId(): string | null {
   );
 }
 
-/**
- * Script hosts the injected GA loader pulls executable code from. Google Tag
- * Manager serves `gtag/js`, and GA4 can lazy-load additional collectors from
- * `www.google-analytics.com`. These must be listed in the document `script-src`
- * so the CSP reflects the code the framework itself injects (see
- * `applyDocumentCsp` in `ssr-handler.ts`).
- */
-export const GA_CSP_SCRIPT_HOSTS = [
-  "https://www.googletagmanager.com",
-  "https://www.google-analytics.com",
-] as const;
-
-/**
- * Network/image hosts used by the GA4 loader when it sends page-view and event
- * beacons. These are separate from `script-src`: a stricter deployment CSP with
- * `connect-src 'self'` or `img-src 'self'` can load gtag.js but still drop all
- * analytics events unless these hosts are present too.
- */
-export const GA_CSP_CONNECT_HOSTS = [
-  "https://www.google-analytics.com",
-  "https://analytics.google.com",
-  "https://stats.g.doubleclick.net",
-  "https://region1.google-analytics.com",
-] as const;
-
-export const GA_CSP_IMG_HOSTS = [
-  "https://www.google-analytics.com",
-  "https://www.googletagmanager.com",
-  "https://stats.g.doubleclick.net",
-] as const;
-
 /**
  * The exact JS body (no surrounding `<script>` tags) of the inline gtag config
- * block injected next to the gtag.js loader. Returned so the SSR handler can
- * hash it for the `script-src` CSP directive — the hash must be computed from
- * the identical string that `getGaScript()` embeds, so both call this helper.
+ * block injected next to the gtag.js loader.
  * Returns `null` when GA is not configured.
  */
 export function getGaInlineConfigScriptBody(): string | null {

package/corpus/core/src/server/ssr-handler.ts

@@ -30,18 +30,11 @@ import {
   AGENT_NATIVE_SOCIAL_IMAGE_WIDTH,
   withAgentNativeSocialImageCacheBuster,
 } from "../shared/social-meta.js";
-import {
-  GA_CSP_CONNECT_HOSTS,
-  GA_CSP_IMG_HOSTS,
-  GA_CSP_SCRIPT_HOSTS,
-  getGaInlineConfigScriptBody,
-} from "./analytics.js";
 import {
   getAppBasePathFromViteEnv,
   stripAppBasePath as canonicalStripAppBasePath,
 } from "./app-base-path.js";
 import { runWithRequestContext } from "./request-context.js";
-import { computeInlineScriptHash } from "./security-headers.js";
 import { getSentryClientConfigScript } from "./sentry-config.js";
 
 export {
@@ -258,376 +251,17 @@ function applyDefaultSpeculationRulesHeader(
 }
 
 /**
- * Extract the plain JS body from a `<script ...>body</script>` string.
- * Returns `null` if the input is falsy or has no recognisable `</script>` end.
- * Used to compute the sha256 hash of framework-injected inline scripts so the
- * hash can be listed in app-owned `script-src` CSP directives.
- */
-function extractScriptBody(scriptTag: string | null): string | null {
-  if (!scriptTag) return null;
-  const start = scriptTag.indexOf(">") + 1;
-  const end = scriptTag.lastIndexOf("</script>");
-  if (start <= 0 || end < start) return null;
-  return scriptTag.slice(start, end);
-}
-
-type CspDirective = {
-  name: string;
-  tokens: string[];
-};
-
-const CSP_DIRECTIVES_WITH_VALUE_TOKENS = new Set([
-  "base-uri",
-  "block-all-mixed-content",
-  "child-src",
-  "connect-src",
-  "default-src",
-  "fenced-frame-src",
-  "font-src",
-  "form-action",
-  "frame-ancestors",
-  "frame-src",
-  "img-src",
-  "manifest-src",
-  "media-src",
-  "navigate-to",
-  "object-src",
-  "plugin-types",
-  "prefetch-src",
-  "referrer",
-  "reflected-xss",
-  "require-sri-for",
-  "require-trusted-types-for",
-  "report-to",
-  "report-uri",
-  "sandbox",
-  "script-src",
-  "script-src-attr",
-  "script-src-elem",
-  "style-src",
-  "style-src-attr",
-  "style-src-elem",
-  "trusted-types",
-  "upgrade-insecure-requests",
-  "webrtc",
-  "worker-src",
-]);
-
-function hasCommaJoinedCspPolicies(policy: string): boolean {
-  let commaIndex = policy.indexOf(",");
-  while (commaIndex !== -1) {
-    const afterComma = policy.slice(commaIndex + 1);
-    const directive = /^\s+([a-z][a-z0-9-]*)(?=\s|;|$)/i.exec(afterComma)?.[1];
-    if (
-      directive &&
-      CSP_DIRECTIVES_WITH_VALUE_TOKENS.has(directive.toLowerCase())
-    ) {
-      return true;
-    }
-    commaIndex = policy.indexOf(",", commaIndex + 1);
-  }
-  return false;
-}
-
-function parseCsp(policy: string): CspDirective[] {
-  return policy
-    .split(";")
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => {
-      const [name = "", ...tokens] = part.split(/\s+/);
-      return { name: name.toLowerCase(), tokens };
-    })
-    .filter((directive) => directive.name);
-}
-
-function serializeCsp(directives: CspDirective[]): string {
-  return directives
-    .map((directive) =>
-      [directive.name, ...directive.tokens].filter(Boolean).join(" "),
-    )
-    .join("; ");
-}
-
-function appendCspTokens(
-  tokens: string[],
-  additions: readonly string[],
-): string[] {
-  if (!additions.length) return tokens;
-  const next = tokens.filter((token) => token !== "'none'");
-  const seen = new Set(next);
-  for (const token of additions) {
-    if (!token || seen.has(token)) continue;
-    next.push(token);
-    seen.add(token);
-  }
-  return next;
-}
-
-function findCspDirective(
-  directives: CspDirective[],
-  name: string,
-): CspDirective | undefined {
-  return directives.find((directive) => directive.name === name);
-}
-
-function appendToExistingOrDefaultCspDirective(
-  directives: CspDirective[],
-  name: string,
-  additions: readonly string[],
-): void {
-  if (!additions.length) return;
-  const existing = findCspDirective(directives, name);
-  if (existing) {
-    existing.tokens = appendCspTokens(existing.tokens, additions);
-    return;
-  }
-
-  const defaultSrc = findCspDirective(directives, "default-src");
-  if (!defaultSrc) return;
-  directives.push({
-    name,
-    tokens: appendCspTokens([...defaultSrc.tokens], additions),
-  });
-}
-
-function appendToExistingCspDirective(
-  directives: CspDirective[],
-  name: string,
-  additions: readonly string[],
-): void {
-  const existing = findCspDirective(directives, name);
-  if (!existing) return;
-  existing.tokens = appendCspTokens(existing.tokens, additions);
-}
-
-function ensureCspDirective(
-  directives: CspDirective[],
-  name: string,
-  tokens: readonly string[],
-): void {
-  if (findCspDirective(directives, name)) return;
-  directives.push({ name, tokens: [...tokens] });
-}
-
-function hasStrictNonceScriptPolicy(tokens: readonly string[]): boolean {
-  return tokens.some(
-    (token) => token === "'strict-dynamic'" || token.startsWith("'nonce-"),
-  );
-}
-
-function appendToScriptCspDirective(
-  directives: CspDirective[],
-  name: string,
-  additions: readonly string[],
-): boolean {
-  const existing = findCspDirective(directives, name);
-  if (existing) {
-    if (hasStrictNonceScriptPolicy(existing.tokens)) return false;
-    existing.tokens = appendCspTokens(existing.tokens, additions);
-    return true;
-  }
-
-  const defaultSrc = findCspDirective(directives, "default-src");
-  if (!defaultSrc || hasStrictNonceScriptPolicy(defaultSrc.tokens)) {
-    return false;
-  }
-  directives.push({
-    name,
-    tokens: appendCspTokens([...defaultSrc.tokens], additions),
-  });
-  return true;
-}
-
-function appendToEffectiveScriptElementCspDirective(
-  directives: CspDirective[],
-  additions: readonly string[],
-): boolean {
-  const scriptSrcElem = findCspDirective(directives, "script-src-elem");
-  if (scriptSrcElem) {
-    if (hasStrictNonceScriptPolicy(scriptSrcElem.tokens)) return false;
-    scriptSrcElem.tokens = appendCspTokens(scriptSrcElem.tokens, additions);
-    return true;
-  }
-
-  return appendToScriptCspDirective(directives, "script-src", additions);
-}
-
-function augmentExistingEnforcedCspForFrameworkScripts(
-  policy: string,
-  options: {
-    gaScriptSrcTokens: readonly string[];
-    gaEnabled: boolean;
-  },
-): string {
-  // Multiple CSP headers are surfaced by Headers.get() as one comma-joined
-  // string. CSP is not a comma-list header, so serializing a parsed combined
-  // value would turn two policies into one invalid policy. Leave those headers
-  // app-owned; a comma inside a source/report URL is still safe to parse.
-  if (hasCommaJoinedCspPolicies(policy)) return policy;
-
-  const directives = parseCsp(policy);
-  if (!directives.length) return policy;
-
-  if (options.gaEnabled) {
-    const addedScriptElement = appendToEffectiveScriptElementCspDirective(
-      directives,
-      options.gaScriptSrcTokens,
-    );
-    if (addedScriptElement) {
-      appendToExistingOrDefaultCspDirective(
-        directives,
-        "connect-src",
-        GA_CSP_CONNECT_HOSTS,
-      );
-      appendToExistingOrDefaultCspDirective(
-        directives,
-        "img-src",
-        GA_CSP_IMG_HOSTS,
-      );
-    }
-  }
-
-  ensureCspDirective(directives, "object-src", ["'none'"]);
-  ensureCspDirective(directives, "base-uri", ["'self'"]);
-
-  return serializeCsp(directives);
-}
-
-function augmentExistingReportOnlyCspForFrameworkScripts(
-  policy: string,
-  options: {
-    scriptSrcTokens: readonly string[];
-    gaEnabled: boolean;
-  },
-): string {
-  if (hasCommaJoinedCspPolicies(policy)) return policy;
-
-  const directives = parseCsp(policy);
-  if (!directives.length) return policy;
-
-  appendToExistingOrDefaultCspDirective(
-    directives,
-    "script-src",
-    options.scriptSrcTokens,
-  );
-  appendToExistingCspDirective(
-    directives,
-    "script-src-elem",
-    options.scriptSrcTokens,
-  );
-
-  if (options.gaEnabled) {
-    appendToExistingOrDefaultCspDirective(
-      directives,
-      "connect-src",
-      GA_CSP_CONNECT_HOSTS,
-    );
-    appendToExistingOrDefaultCspDirective(
-      directives,
-      "img-src",
-      GA_CSP_IMG_HOSTS,
-    );
-  }
-
-  return serializeCsp(directives);
-}
-
-/**
- * Apply a Content-Security-Policy header to HTML document responses.
+ * Strip document-level CSP from app HTML responses.
  *
- * Two directives are always enforced in production:
- *
- *   - `object-src 'none'`  — disables Flash / Java / PDF plugin execution,
- *     which are a reliable code-execution vector even in modern browsers.
- *   - `base-uri 'self'`    — prevents a `<base href="...">` injection from
- *     hijacking all relative URLs in the document (a common attack target when
- *     user-controlled content reaches the HTML).
- *
- * A third directive, `script-src`, is emitted via `Content-Security-Policy-
- * Report-Only` rather than enforced when the app has no existing document CSP.
- * The framework injects inline scripts for analytics, Sentry, and template
- * setup, and hosted apps need Google Tag Manager to load without noisy CSP
- * diagnostics. The report-only policy is intentionally permissive for scripts:
- * it includes `'unsafe-inline'` plus the known GA/GTM loader hosts.
- *
- * If an app or host already sends an enforced CSP with `script-src`,
- * `script-src-elem`, `connect-src`, `img-src`, or `default-src`, we merge only
- * GA-specific allowances into existing host/hash policies. Strict nonce or
- * `strict-dynamic` script policies stay app-owned because blindly appending
- * hashes or hosts would widen the policy without reliably loading our injected
- * scripts.
- *
- * Templates additionally render a theme-init inline script whose exact content
- * varies by template (default theme param, custom docs variant, etc.) and which
- * is rendered by React Router, not this handler, so its hash is not available
- * here. Shipping script-src as Report-Only surfaces the remaining violations
- * without breaking template customisations; teams can graduate to enforcement
- * once their hashes are enumerated.
- *
- * Skipped in development (`NODE_ENV !== 'production'`) so HMR eval and Vite
- * dev-server injects are never blocked. Set `AGENT_NATIVE_DISABLE_DOC_CSP=1`
- * to opt out in production for a template with exotic needs.
+ * Hosted templates inject framework bootstrap scripts, analytics, Sentry config,
+ * and app-owned inline scripts whose exact bytes vary by build/template. Any
+ * shared CSP header, even Report-Only, can block or noisily report Google Tag
+ * Manager and those bootstraps. Extension iframes and webviews keep their own
+ * route-specific sandboxes; normal app documents deliberately do not emit CSP.
  */
-function applyDocumentCsp(headers: Headers, sentryScript: string | null): void {
-  if (process.env.NODE_ENV !== "production") return;
-  if (process.env.AGENT_NATIVE_DISABLE_DOC_CSP === "1") return;
-
-  // script-src as Report-Only: keep this deliberately loose so the framework's
-  // injected analytics and template bootstrap scripts do not look blocked in
-  // browser diagnostics.
-  const sentryBody = extractScriptBody(sentryScript);
-  const sentryHash = sentryBody ? computeInlineScriptHash(sentryBody) : null;
-  const gaInlineBody = getGaInlineConfigScriptBody();
-  const gaHash = gaInlineBody ? computeInlineScriptHash(gaInlineBody) : null;
-  const gaHosts = gaInlineBody ? [...GA_CSP_SCRIPT_HOSTS] : [];
-  const gaScriptSrcTokens = [
-    "'unsafe-inline'",
-    ...(gaHash ? [gaHash] : []),
-    ...gaHosts,
-  ];
-  const scriptSrcTokens = [
-    "'self'",
-    "'unsafe-inline'",
-    ...(sentryHash ? [sentryHash] : []),
-    ...(gaHash ? [gaHash] : []),
-    ...gaHosts,
-  ];
-
-  const cspAugmentOptions = {
-    scriptSrcTokens,
-    gaScriptSrcTokens,
-    gaEnabled: Boolean(gaInlineBody),
-  };
-  const existing = headers.get("content-security-policy") ?? "";
-  if (!existing) {
-    headers.set(
-      "content-security-policy",
-      "object-src 'none'; base-uri 'self'",
-    );
-  } else {
-    headers.set(
-      "content-security-policy",
-      augmentExistingEnforcedCspForFrameworkScripts(
-        existing,
-        cspAugmentOptions,
-      ),
-    );
-  }
-
-  const scriptSrc = `script-src ${scriptSrcTokens.join(" ")}`;
-  const existingRo = headers.get("content-security-policy-report-only") ?? "";
-  if (!existingRo) {
-    headers.set("content-security-policy-report-only", scriptSrc);
-  } else {
-    headers.set(
-      "content-security-policy-report-only",
-      augmentExistingReportOnlyCspForFrameworkScripts(
-        existingRo,
-        cspAugmentOptions,
-      ),
-    );
-  }
+function removeDocumentCsp(headers: Headers): void {
+  headers.delete("content-security-policy");
+  headers.delete("content-security-policy-report-only");
 }
 
 function isFrameworkOrAssetPath(pathname: string): boolean {
@@ -665,7 +299,15 @@ async function rewriteMountedResponse(
   }
 
   const contentType = headers.get("content-type") ?? "";
-  if (!contentType.toLowerCase().includes("text/html") || !response.body) {
+  if (!contentType.toLowerCase().includes("text/html")) {
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  }
+  removeDocumentCsp(headers);
+  if (!response.body) {
     return new Response(response.body, {
       status: response.status,
       statusText: response.statusText,
@@ -675,7 +317,6 @@ async function rewriteMountedResponse(
 
   const html = await response.text();
   headers.delete("content-length");
-  applyDocumentCsp(headers, sentryClientConfigScript);
   return new Response(
     injectHeadScript(
       injectDefaultSocialImageMeta(

package/corpus/templates/clips/server/routes/api/video/[recordingId].get.ts

@@ -349,8 +349,6 @@ function loomEmbedResponse(embedUrl: string): Response {
       "Cache-Control": "private, max-age=0, no-store",
       "Referrer-Policy": "no-referrer",
       "X-Content-Type-Options": "nosniff",
-      "Content-Security-Policy":
-        "default-src 'none'; frame-src https://www.loom.com; style-src 'unsafe-inline'",
     },
   });
 }

package/corpus/templates/design/changelog/2026-07-03-design-chat-recovers-stuck-screen-edits-inside-the-worker.md

@@ -0,0 +1,5 @@
+---
+type: fixed
+---
+
+Design chat now keeps selected-variant screen edits moving when a large edit stalls during preparation, instead of leaving the chat waiting for a browser-side recovery.

package/corpus/templates/forms/server/lib/public-form-ssr.ts

@@ -279,7 +279,6 @@ export async function renderPublicForm(event: H3Event) {
 
   const headers: Record<string, string> = {
     "Content-Type": "text/html; charset=utf-8",
-    "Content-Security-Policy": "frame-ancestors *",
   };
   if (status === 200) {
     // Public form SSR is anonymous HTML and follows the same framework-level