@agent-native/core 0.77.10 → 0.77.12

package/corpus/README.md

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

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.77.12
+
+### Patch Changes
+
+- 67dba9b: Sync builder-agent-native-starter toolchain files (React Router config, Vite config, server plugins, etc.) alongside the manifest so dependency bumps from templates/chat do not leave the starter in a broken state. Standalone UI scaffolds re-declare tsconfig `paths` and `baseUrl` for `@/*` resolution; headless scaffolds omit `baseUrl` for TS 6 tsgo compatibility. Netlify post-process now rewrites unindented template build commands.
+
+## 0.77.11
+
+### Patch Changes
+
+- 7560a7c: Clear collaborative awareness state immediately when an editor leaves a document.
+
 ## 0.77.10
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.77.10",
+  "version": "0.77.12",
   "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": {
@@ -211,8 +211,8 @@
     "@react-router/dev": "^8.0.1",
     "@react-router/fs-routes": "^8.0.1",
     "@resvg/resvg-js": "^2.6.2",
-    "@sentry/browser": "^10.61.0",
-    "@sentry/node": "^10.61.0",
+    "@sentry/browser": "10.60.0",
+    "@sentry/node": "10.60.0",
     "@standard-schema/spec": "^1.1.0",
     "@tanstack/react-table": "^8.21.3",
     "@tiptap/core": "3.27.1",

package/corpus/core/src/cli/create.ts

@@ -27,19 +27,7 @@ const STANDALONE_EXACT_DEPENDENCY_OVERRIDES: Record<string, string> = {
   "@react-router/fs-routes": "8.0.1",
   "react-router": "8.0.1",
 };
-const SENTRY_MINIMUM_RELEASE_AGE_EXCLUDES = [
-  '"@sentry/browser"',
-  '"@sentry/browser-utils"',
-  '"@sentry/conventions"',
-  '"@sentry/core"',
-  '"@sentry/feedback"',
-  '"@sentry/node"',
-  '"@sentry/node-core"',
-  '"@sentry/opentelemetry"',
-  '"@sentry/replay"',
-  '"@sentry/replay-canvas"',
-  '"@sentry/server-utils"',
-];
+const SENTRY_MINIMUM_RELEASE_AGE_EXCLUDES = ['"@sentry/*"'];
 const FIRST_PARTY_TARBALL_SYMLINK_EXCLUDES = [
   "*/CLAUDE.md",
   "*/.claude/skills",
@@ -978,6 +966,7 @@ function postProcessStandalone(
   const appTitle = appTitleForScaffold(name);
   replacePlaceholders(targetDir, name, appTitle);
   rewriteTrackingAppId(targetDir, name, templateName);
+  rewriteAgentChatAppId(targetDir, name, templateName);
   fixPackageJsonName(targetDir, name, templateName);
   fixWebManifestName(targetDir, name, templateName);
   rewriteNetlifyToml(targetDir, name, "standalone");
@@ -1078,9 +1067,40 @@ function postProcessStandalone(
     }
   } catch {}
 
+  fixStandaloneTsconfig(targetDir, templateName);
+
   setupAgentSymlinks(targetDir);
 }
 
+function fixStandaloneTsconfig(targetDir: string, templateName?: string): void {
+  const tsconfigPath = path.join(targetDir, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) return;
+  try {
+    const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, "utf-8")) as {
+      compilerOptions?: Record<string, unknown>;
+    };
+    tsconfig.compilerOptions ??= {};
+    const hasUiApp =
+      templateName !== "headless" && fs.existsSync(path.join(targetDir, "app"));
+    const paths = {
+      ...((tsconfig.compilerOptions.paths as Record<string, string[]>) ?? {}),
+    };
+    paths["*"] ??= ["./*"];
+    if (hasUiApp) {
+      paths["@/*"] ??= ["./app/*"];
+      paths["@shared/*"] ??= ["./shared/*"];
+      // Child baseUrl anchors @/* for apps extending legacy core tsconfig bases
+      // that still ship baseUrl. Headless scaffolds omit it so raw tsgo --noEmit
+      // keeps working under TS 6.
+      tsconfig.compilerOptions.baseUrl = ".";
+    } else {
+      delete tsconfig.compilerOptions.baseUrl;
+    }
+    tsconfig.compilerOptions.paths = paths;
+    fs.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}\n`);
+  } catch {}
+}
+
 /* ─────────────────────────────────────────────────────────────────────────
  * Prompting helpers
  * ───────────────────────────────────────────────────────────────────────── */
@@ -1734,7 +1754,7 @@ function rewriteNetlifyToml(
 
   try {
     let content = fs.readFileSync(netlifyPath, "utf-8");
-    const originalCommand = content.match(/^  command = "([^"]*)"$/m)?.[1];
+    const originalCommand = content.match(/^\s*command = "([^"]*)"$/m)?.[1];
     const usesUnpooledDatabase =
       originalCommand?.includes("NETLIFY_DATABASE_URL_UNPOOLED") ?? false;
     const buildCommand =
@@ -1754,7 +1774,7 @@ function rewriteNetlifyToml(
         : ".netlify/functions-internal";
 
     content = content
-      .replace(/^  command = ".*"$/m, `  command = "${command}"`)
+      .replace(/^(\s*)command = ".*"$/m, `$1command = "${command}"`)
       .replace(
         /publish = "templates\/[^"]+\/dist"/g,
         `publish = "${publishPath}"`,
@@ -1776,6 +1796,36 @@ function rewriteNetlifyToml(
   } catch {}
 }
 
+function rewriteAgentChatAppId(
+  appDir: string,
+  appName: string,
+  templateName?: string,
+): void {
+  const pluginPath = path.join(appDir, "server", "plugins", "agent-chat.ts");
+  if (!fs.existsSync(pluginPath)) return;
+
+  try {
+    const content = fs.readFileSync(pluginPath, "utf-8");
+    const sourceAppIds = ["chat", "starter"];
+    if (templateName && templateName !== appName) {
+      sourceAppIds.push(templateName);
+    }
+    const pattern = new RegExp(
+      `(appId:\\s*)(["'])(${sourceAppIds.map(escapeRegExp).join("|")})\\2`,
+    );
+    if (!pattern.test(content)) return;
+
+    const next = content.replace(
+      pattern,
+      (_match, prefix: string, quote: string) =>
+        `${prefix}${quote}${appName}${quote}`,
+    );
+    if (next !== content) {
+      fs.writeFileSync(pluginPath, next);
+    }
+  } catch {}
+}
+
 function rewriteTrackingAppId(
   appDir: string,
   appName: string,

package/corpus/core/src/cli/sync-builder-starter-manifest.ts

@@ -8,8 +8,45 @@ import { _postProcessStandalone } from "./create.js";
 export const STARTER_APP_NAME = "builder-agent-native-starter";
 export const CHAT_TEMPLATE = "chat";
 
+/** Toolchain files that must track templates/chat or typecheck/build drift. */
+export const STARTER_TOOLCHAIN_SYNC_PATHS = [
+  "react-router.config.ts",
+  "vite.config.ts",
+  "tsconfig.json",
+  "ssr-entry.ts",
+  "app/vite-env.d.ts",
+  "app/routes.ts",
+  "server/routes/[...page].get.ts",
+  // server/plugins/* are intentionally excluded: starter keeps its own
+  // systemPrompt and auth marketing copy; post-process only rewrites appId/title.
+  "server/middleware/auth.ts",
+  "components.json",
+  ".oxfmtrc.json",
+  "netlify.toml",
+] as const;
+
+export type StarterToolchainSyncPath =
+  (typeof STARTER_TOOLCHAIN_SYNC_PATHS)[number];
+
 type PackageJson = Record<string, unknown>;
 
+export type StandaloneChatSnapshot = {
+  cleanup: () => void;
+  dir: string;
+  packageJson: PackageJson;
+  pnpmWorkspaceYaml: string | null;
+  toolchainFiles: Map<StarterToolchainSyncPath, string>;
+};
+
+export function listStarterSyncPaths(): string[] {
+  return [
+    "package.json",
+    "pnpm-lock.yaml",
+    "pnpm-workspace.yaml",
+    ...STARTER_TOOLCHAIN_SYNC_PATHS,
+  ];
+}
+
 export function findAgentNativeRoot(startDir = process.cwd()): string {
   let dir = path.resolve(startDir);
   for (let i = 0; i < 12; i++) {
@@ -31,32 +68,62 @@ export function findAgentNativeRoot(startDir = process.cwd()): string {
   );
 }
 
-export function generateStandaloneChatManifest(repoRoot?: string): {
-  packageJson: PackageJson;
-  pnpmWorkspaceYaml: string | null;
-} {
+export function collectStarterToolchainFiles(
+  canonicalDir: string,
+): Map<StarterToolchainSyncPath, string> {
+  const files = new Map<StarterToolchainSyncPath, string>();
+  for (const relativePath of STARTER_TOOLCHAIN_SYNC_PATHS) {
+    const absolutePath = path.join(canonicalDir, relativePath);
+    if (!fs.existsSync(absolutePath)) continue;
+    files.set(relativePath, fs.readFileSync(absolutePath, "utf-8"));
+  }
+  return files;
+}
+
+export function createStandaloneChatSnapshot(
+  repoRoot?: string,
+): StandaloneChatSnapshot {
   const root = repoRoot ?? findAgentNativeRoot();
   const chatTemplateDir = path.join(root, "templates", CHAT_TEMPLATE);
   const tempDir = fs.mkdtempSync(
     path.join(os.tmpdir(), "an-builder-starter-sync-"),
   );
 
-  try {
-    fs.cpSync(chatTemplateDir, tempDir, { recursive: true });
-    _postProcessStandalone(STARTER_APP_NAME, tempDir, CHAT_TEMPLATE);
+  fs.cpSync(chatTemplateDir, tempDir, { recursive: true });
+  _postProcessStandalone(STARTER_APP_NAME, tempDir, CHAT_TEMPLATE);
 
-    const packageJson = JSON.parse(
-      fs.readFileSync(path.join(tempDir, "package.json"), "utf-8"),
-    ) as PackageJson;
+  const packageJson = JSON.parse(
+    fs.readFileSync(path.join(tempDir, "package.json"), "utf-8"),
+  ) as PackageJson;
 
-    const workspacePath = path.join(tempDir, "pnpm-workspace.yaml");
-    const pnpmWorkspaceYaml = fs.existsSync(workspacePath)
-      ? fs.readFileSync(workspacePath, "utf-8")
-      : null;
+  const workspacePath = path.join(tempDir, "pnpm-workspace.yaml");
+  const pnpmWorkspaceYaml = fs.existsSync(workspacePath)
+    ? fs.readFileSync(workspacePath, "utf-8")
+    : null;
 
-    return { packageJson, pnpmWorkspaceYaml };
+  return {
+    cleanup: () => {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    },
+    dir: tempDir,
+    packageJson,
+    pnpmWorkspaceYaml,
+    toolchainFiles: collectStarterToolchainFiles(tempDir),
+  };
+}
+
+export function generateStandaloneChatManifest(repoRoot?: string): {
+  packageJson: PackageJson;
+  pnpmWorkspaceYaml: string | null;
+} {
+  const snapshot = createStandaloneChatSnapshot(repoRoot);
+  try {
+    return {
+      packageJson: snapshot.packageJson,
+      pnpmWorkspaceYaml: snapshot.pnpmWorkspaceYaml,
+    };
   } finally {
-    fs.rmSync(tempDir, { recursive: true, force: true });
+    snapshot.cleanup();
   }
 }
 
@@ -144,73 +211,185 @@ function stableJson(value: unknown): string {
   return `${JSON.stringify(value, null, 2)}\n`;
 }
 
+export type StarterToolchainSyncChange = {
+  relativePath: StarterToolchainSyncPath;
+  changed: boolean;
+};
+
+export function diffStarterToolchainFiles(
+  starterDir: string,
+  canonicalFiles: Map<StarterToolchainSyncPath, string>,
+): StarterToolchainSyncChange[] {
+  return STARTER_TOOLCHAIN_SYNC_PATHS.map((relativePath) => {
+    const canonicalContent = canonicalFiles.get(relativePath) ?? null;
+    const targetPath = path.join(starterDir, relativePath);
+    const existingContent = fs.existsSync(targetPath)
+      ? fs.readFileSync(targetPath, "utf-8")
+      : null;
+    return {
+      relativePath,
+      changed: existingContent !== canonicalContent,
+    };
+  });
+}
+
+export function applyStarterToolchainSync(
+  starterDir: string,
+  canonicalFiles: Map<StarterToolchainSyncPath, string>,
+): StarterToolchainSyncChange[] {
+  const changes: StarterToolchainSyncChange[] = [];
+  for (const relativePath of STARTER_TOOLCHAIN_SYNC_PATHS) {
+    const canonicalContent = canonicalFiles.get(relativePath) ?? null;
+    const targetPath = path.join(starterDir, relativePath);
+    const existingContent = fs.existsSync(targetPath)
+      ? fs.readFileSync(targetPath, "utf-8")
+      : null;
+    const changed = existingContent !== canonicalContent;
+    if (changed) {
+      if (canonicalContent === null) {
+        if (fs.existsSync(targetPath)) {
+          fs.unlinkSync(targetPath);
+        }
+      } else {
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.writeFileSync(targetPath, canonicalContent);
+      }
+    }
+    changes.push({ relativePath, changed });
+  }
+  return changes;
+}
+
 export type SyncStarterManifestResult = {
   changed: boolean;
+  packageChanged: boolean;
+  workspaceChanged: boolean;
   packageJson: PackageJson;
   pnpmWorkspaceYaml: string | null;
+  toolchainChanges: StarterToolchainSyncChange[];
+  changedToolchainPaths: StarterToolchainSyncPath[];
 };
 
-export function syncStarterManifestFiles(options: {
+export function resolveStarterPaths(options: {
+  starterDir?: string;
+  starterPackageJsonPath?: string;
+  starterPnpmWorkspacePath?: string;
+}): {
+  starterDir: string;
   starterPackageJsonPath: string;
+  starterPnpmWorkspacePath: string;
+} {
+  if (options.starterDir) {
+    return {
+      starterDir: path.resolve(options.starterDir),
+      starterPackageJsonPath: path.join(
+        path.resolve(options.starterDir),
+        "package.json",
+      ),
+      starterPnpmWorkspacePath: path.join(
+        path.resolve(options.starterDir),
+        "pnpm-workspace.yaml",
+      ),
+    };
+  }
+  if (!options.starterPackageJsonPath) {
+    throw new Error("Provide --starter-dir or --starter-package-json.");
+  }
+  const starterPackageJsonPath = path.resolve(options.starterPackageJsonPath);
+  return {
+    starterDir: path.dirname(starterPackageJsonPath),
+    starterPackageJsonPath,
+    starterPnpmWorkspacePath:
+      options.starterPnpmWorkspacePath ??
+      path.join(path.dirname(starterPackageJsonPath), "pnpm-workspace.yaml"),
+  };
+}
+
+export function syncStarterManifestFiles(options: {
+  starterDir?: string;
+  starterPackageJsonPath?: string;
   starterPnpmWorkspacePath?: string;
   repoRoot?: string;
   write?: boolean;
 }): SyncStarterManifestResult {
-  const { packageJson: canonical, pnpmWorkspaceYaml } =
-    generateStandaloneChatManifest(options.repoRoot);
+  const { starterDir, starterPackageJsonPath, starterPnpmWorkspacePath } =
+    resolveStarterPaths(options);
+  const snapshot = createStandaloneChatSnapshot(options.repoRoot);
 
-  const starterPackageJson = JSON.parse(
-    fs.readFileSync(options.starterPackageJsonPath, "utf-8"),
-  ) as PackageJson;
-  const mergedPackageJson = mergeStarterManifest(starterPackageJson, canonical);
+  try {
+    const starterPackageJson = JSON.parse(
+      fs.readFileSync(starterPackageJsonPath, "utf-8"),
+    ) as PackageJson;
+    const mergedPackageJson = mergeStarterManifest(
+      starterPackageJson,
+      snapshot.packageJson,
+    );
 
-  let workspaceChanged = false;
-  const existingWorkspace =
-    options.starterPnpmWorkspacePath &&
-    fs.existsSync(options.starterPnpmWorkspacePath)
-      ? fs.readFileSync(options.starterPnpmWorkspacePath, "utf-8")
+    const existingWorkspace = fs.existsSync(starterPnpmWorkspacePath)
+      ? fs.readFileSync(starterPnpmWorkspacePath, "utf-8")
       : null;
 
-  workspaceChanged = workspaceFileSyncChanged(
-    existingWorkspace,
-    pnpmWorkspaceYaml,
-  );
-
-  const packageChanged =
-    stableJson(starterPackageJson) !== stableJson(mergedPackageJson);
-  const changed = packageChanged || workspaceChanged;
-
-  if (options.write && changed) {
-    if (packageChanged) {
-      fs.writeFileSync(
-        options.starterPackageJsonPath,
-        stableJson(mergedPackageJson),
-      );
-    }
-    if (workspaceChanged && options.starterPnpmWorkspacePath) {
-      applyWorkspaceFileSync(
-        options.starterPnpmWorkspacePath,
-        pnpmWorkspaceYaml,
-      );
+    const workspaceChanged = workspaceFileSyncChanged(
+      existingWorkspace,
+      snapshot.pnpmWorkspaceYaml,
+    );
+    const packageChanged =
+      stableJson(starterPackageJson) !== stableJson(mergedPackageJson);
+    const toolchainChanges = diffStarterToolchainFiles(
+      starterDir,
+      snapshot.toolchainFiles,
+    );
+    const changedToolchainPaths = toolchainChanges
+      .filter((change) => change.changed)
+      .map((change) => change.relativePath);
+    const changed =
+      packageChanged || workspaceChanged || changedToolchainPaths.length > 0;
+
+    if (options.write && changed) {
+      if (packageChanged) {
+        fs.writeFileSync(starterPackageJsonPath, stableJson(mergedPackageJson));
+      }
+      if (workspaceChanged) {
+        applyWorkspaceFileSync(
+          starterPnpmWorkspacePath,
+          snapshot.pnpmWorkspaceYaml,
+        );
+      }
+      if (changedToolchainPaths.length > 0) {
+        applyStarterToolchainSync(starterDir, snapshot.toolchainFiles);
+      }
     }
-  }
 
-  return {
-    changed,
-    packageJson: mergedPackageJson,
-    pnpmWorkspaceYaml,
-  };
+    return {
+      changed,
+      packageChanged,
+      workspaceChanged,
+      packageJson: mergedPackageJson,
+      pnpmWorkspaceYaml: snapshot.pnpmWorkspaceYaml,
+      toolchainChanges,
+      changedToolchainPaths,
+    };
+  } finally {
+    snapshot.cleanup();
+  }
 }
 
 export function parseSyncStarterManifestArgs(argv: string[]): {
-  command: "merge" | "generate";
+  command: "merge" | "generate" | "paths";
+  starterDir?: string;
   starterPackageJsonPath?: string;
   starterPnpmWorkspacePath?: string;
   write: boolean;
   repoRoot?: string;
 } {
   const [commandRaw, ...rest] = argv;
-  const command = commandRaw === "generate" ? "generate" : "merge";
+  const command =
+    commandRaw === "generate"
+      ? "generate"
+      : commandRaw === "paths"
+        ? "paths"
+        : "merge";
+  let starterDir: string | undefined;
   let starterPackageJsonPath: string | undefined;
   let starterPnpmWorkspacePath: string | undefined;
   let write = false;
@@ -222,6 +401,10 @@ export function parseSyncStarterManifestArgs(argv: string[]): {
       write = true;
       continue;
     }
+    if (arg === "--starter-dir") {
+      starterDir = rest[++i];
+      continue;
+    }
     if (arg === "--starter-package-json") {
       starterPackageJsonPath = rest[++i];
       continue;
@@ -237,14 +420,15 @@ export function parseSyncStarterManifestArgs(argv: string[]): {
     throw new Error(`Unknown argument: ${arg}`);
   }
 
-  if (command === "merge" && !starterPackageJsonPath) {
+  if (command === "merge" && !starterDir && !starterPackageJsonPath) {
     throw new Error(
-      "merge requires --starter-package-json <path> [--starter-pnpm-workspace <path>] [--write] [--repo-root <path>]",
+      "merge requires --starter-dir <path> or --starter-package-json <path> [--starter-pnpm-workspace <path>] [--write] [--repo-root <path>]",
     );
   }
 
   return {
     command,
+    starterDir,
     starterPackageJsonPath,
     starterPnpmWorkspacePath,
     write,
@@ -267,25 +451,37 @@ export function runSyncStarterManifestCli(argv: string[]): number {
     return 0;
   }
 
+  if (args.command === "paths") {
+    for (const syncPath of listStarterSyncPaths()) {
+      process.stdout.write(`${syncPath}\n`);
+    }
+    return 0;
+  }
+
   const result = syncStarterManifestFiles({
-    starterPackageJsonPath: args.starterPackageJsonPath!,
+    starterDir: args.starterDir,
+    starterPackageJsonPath: args.starterPackageJsonPath,
     starterPnpmWorkspacePath: args.starterPnpmWorkspacePath,
     repoRoot: args.repoRoot,
     write: args.write,
   });
 
   if (result.changed) {
+    const updatedPaths = [
+      ...(result.packageChanged ? ["package.json"] : []),
+      ...(result.workspaceChanged ? ["pnpm-workspace.yaml"] : []),
+      ...result.changedToolchainPaths,
+    ];
+    const summary = updatedPaths.length ? ` (${updatedPaths.join(", ")})` : "";
     console.log(
       args.write
-        ? "Updated builder-agent-native-starter manifest from templates/chat."
-        : "builder-agent-native-starter manifest is out of date with templates/chat.",
+        ? `Updated builder-agent-native-starter from templates/chat${summary}.`
+        : `builder-agent-native-starter is out of date with templates/chat${summary}.`,
     );
     return args.write ? 0 : 1;
   }
 
-  console.log(
-    "builder-agent-native-starter manifest already matches templates/chat.",
-  );
+  console.log("builder-agent-native-starter already matches templates/chat.");
   return 0;
 }
 

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

@@ -102,7 +102,7 @@ function pruneIfEmpty(docId: string, map: Map<number, AwarenessEntry>): void {
  *
  * Client sends its awareness state and receives other clients' states.
  *
- * Body: { clientId: number, state: string (base64) }
+ * Body: { clientId: number, state: string | null (JSON-encoded awareness state, or null to clear) }
  * Response: { states: Array<{ clientId: number, state: string }> }
  */
 export const postAwareness = defineEventHandler(async (event: H3Event) => {
@@ -115,28 +115,31 @@ export const postAwareness = defineEventHandler(async (event: H3Event) => {
   const body = await readBody(event);
   const { clientId, state } = body as {
     clientId?: number;
-    state?: string;
+    state?: string | null;
   };
 
-  if (clientId == null || !state) {
+  if (clientId == null || state === undefined) {
     // `!clientId` would wrongly reject clientId === 0, which is a valid
-    // (if rare) Yjs client id. Only reject missing/null ids here.
+    // (if rare) Yjs client id. A null state is valid: it clears this client.
     setResponseStatus(event, 400);
     return { error: "clientId and state required" };
   }
 
   const map = getDocAwareness(docId);
 
-  // Store this client's state
-  map.set(clientId, { clientId, state, lastSeen: Date.now() });
+  if (state === null) {
+    map.delete(clientId);
+  } else {
+    // Store this client's state
+    map.set(clientId, { clientId, state, lastSeen: Date.now() });
+  }
 
   // Clean expired entries, then prune the outer-map entry if it becomes empty.
   // Without pruning, a deployment with many transient docIds (e.g. one per
   // session) would grow _awarenessMap without bound.
   cleanExpired(map);
-  // map has at least the sender's entry so size >= 1 here; pruneIfEmpty is a
-  // no-op in the normal path but guards against edge cases (e.g. clientId 0
-  // that was immediately evicted by a concurrent cleanExpired run).
+  // Null-state clears and expiry can empty the map; prune the outer entry so
+  // transient document ids do not accumulate.
   pruneIfEmpty(docId, map);
 
   // Build the full list of current states (all clients including sender).

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

@@ -276,11 +276,13 @@ function scheduleAwarenessPush(
   const timer = setTimeout(() => {
     _awarenessThrottleTimers.delete(key);
     const state = getState();
-    if (!state) return;
     fetch(`${baseUrl}/${docId}/awareness`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ clientId, state: JSON.stringify(state) }),
+      body: JSON.stringify({
+        clientId,
+        state: state ? JSON.stringify(state) : null,
+      }),
     }).catch(() => {}); // best-effort; poll cycle is the baseline fallback
   }, 150);
 

package/corpus/templates/clips/actions/finalize-recording.ts

@@ -349,7 +349,7 @@ export default defineAction({
 
         if (!hasPlayableMp4Metadata(uploadData)) {
           const err = new Error(
-            "Recorded MP4 is missing playback metadata. Please retry the recording.",
+            "Recorded MP4 is corrupted or incomplete and cannot be recovered. Please record again.",
           );
           try {
             captureRouteError(err, {

package/corpus/templates/clips/chrome-extension/package.json

@@ -11,7 +11,7 @@
     "package": "pnpm build && tsx scripts/package.ts"
   },
   "dependencies": {
-    "@sentry/browser": "^10.61.0"
+    "@sentry/browser": "10.60.0"
   },
   "devDependencies": {
     "@types/chrome": "^0.2.0",