@agent-native/core 0.70.1 → 0.70.3

package/corpus/README.md

@@ -27,5 +27,5 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 1146
-- template files: 3993
+- core files: 1147
+- template files: 3996

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.70.3
+
+### Patch Changes
+
+- 3c80603: Document and regression-test that `useActionQuery` / `callAction` GET calls round-trip boolean and number params. Browser query params are serialized through `URLSearchParams`, which stringifies everything — so `useActionQuery("instrument-overview", { includeSeries: true, limit: 5 })` sends `includeSeries: "true"` / `limit: "5"`. Schema-aware coercion (added in 0.70.2) already restores native types before validation, but it was framed and tested only as a model-gateway concern. This adds an end-to-end regression test through the action route for the GET path and broadens the coercion doc comment so it is not narrowed to gateway-only and silently re-break browser GET calls. No runtime behavior change.
+
+## 0.70.2
+
+### Patch Changes
+
+- 2d36525: Add a sync helper for keeping Builder Agent Native Starter's standalone manifest aligned with the chat template scaffold output.
+
 ## 0.70.1
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.70.1",
+  "version": "0.70.3",
   "type": "module",
   "engines": {
     "node": ">=22"

package/corpus/core/src/action.ts

@@ -956,16 +956,27 @@ function coerceStringToSchemaType(raw: string, types: string[]): unknown {
 }
 
 /**
- * Defensively coerce gateway-stringified tool arguments to the types the schema
- * expects. Some model gateways (notably Builder's Gemini-backed gateway) hand
- * back structured tool-call arguments as JSON strings — an array param arrives
- * as `"[{...}]"`, a boolean as `"true"`. Standard Schema (zod) `validate` does
- * not coerce, so these fail validation and the agent thrashes retrying shapes
- * (and can hang). We only touch a string value when the schema expects a
- * non-string type and the string parses cleanly to it; anything ambiguous
- * (schema also allows string) or unparseable is left as-is. Operates on
- * top-level properties only — once an array/object param is parsed, its nested
- * members are already native and validate normally.
+ * Defensively coerce stringified action arguments to the types the schema
+ * expects. Two callers depend on this:
+ *
+ *   1. Model gateways (notably Builder's Gemini-backed gateway) hand back
+ *      structured tool-call arguments as JSON strings — an array param arrives
+ *      as `"[{...}]"`, a boolean as `"true"`.
+ *   2. GET actions called from the browser via `useActionQuery` / `callAction`.
+ *      Those serialize params into the query string, where `URLSearchParams`
+ *      stringifies everything — so `includeSeries: true` arrives as the string
+ *      `"true"` and `limit: 5` as `"5"` (see `action-routes.ts`).
+ *
+ * In both cases Standard Schema (zod) `validate` does not coerce, so the call
+ * fails validation ("expected boolean, received string") — the agent thrashes
+ * retrying shapes and the frontend query errors. We only touch a string value
+ * when the schema expects a non-string type and the string parses cleanly to
+ * it; anything ambiguous (schema also allows string) or unparseable is left
+ * as-is. Operates on top-level properties only — once an array/object param is
+ * parsed, its nested members are already native and validate normally.
+ *
+ * Do NOT narrow this to "gateway-only": the GET query-string path relies on it
+ * too, and `action-routes.spec.ts` guards that round-trip.
  */
 function coerceGatewayStringifiedArgs(
   args: unknown,

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

@@ -0,0 +1,275 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { _postProcessStandalone } from "./create.js";
+
+export const STARTER_APP_NAME = "builder-agent-native-starter";
+export const CHAT_TEMPLATE = "chat";
+
+type PackageJson = Record<string, unknown>;
+
+export function findAgentNativeRoot(startDir = process.cwd()): string {
+  let dir = path.resolve(startDir);
+  for (let i = 0; i < 12; i++) {
+    const chatPackageJson = path.join(
+      dir,
+      "templates",
+      CHAT_TEMPLATE,
+      "package.json",
+    );
+    if (fs.existsSync(chatPackageJson)) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    "Could not find agent-native repo root (expected templates/chat/package.json).",
+  );
+}
+
+export function generateStandaloneChatManifest(repoRoot?: string): {
+  packageJson: PackageJson;
+  pnpmWorkspaceYaml: string | null;
+} {
+  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);
+
+    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;
+
+    return { packageJson, pnpmWorkspaceYaml };
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+export function mergeStarterManifest(
+  starterPackageJson: PackageJson,
+  canonicalPackageJson: PackageJson,
+): PackageJson {
+  const merged = structuredClone(canonicalPackageJson) as PackageJson;
+
+  merged.name = starterPackageJson.name ?? STARTER_APP_NAME;
+  if (typeof starterPackageJson.displayName === "string") {
+    merged.displayName = starterPackageJson.displayName;
+  }
+  if (typeof starterPackageJson.description === "string") {
+    merged.description = starterPackageJson.description;
+  }
+  if (starterPackageJson.private !== undefined) {
+    merged.private = starterPackageJson.private;
+  }
+
+  const starterDeps =
+    (starterPackageJson.dependencies as Record<string, string> | undefined) ??
+    {};
+  const canonicalDeps =
+    (canonicalPackageJson.dependencies as Record<string, string> | undefined) ??
+    {};
+  merged.dependencies = {
+    ...canonicalDeps,
+    ...(starterDeps["@agent-native/core"]
+      ? { "@agent-native/core": starterDeps["@agent-native/core"] }
+      : {}),
+  };
+
+  return merged;
+}
+
+export function workspaceFileSyncChanged(
+  existingWorkspace: string | null,
+  canonicalWorkspace: string | null,
+): boolean {
+  if (canonicalWorkspace === null) {
+    return existingWorkspace !== null;
+  }
+  return existingWorkspace !== canonicalWorkspace;
+}
+
+export function applyWorkspaceFileSync(
+  targetPath: string,
+  canonicalWorkspace: string | null,
+): void {
+  if (canonicalWorkspace === null) {
+    if (fs.existsSync(targetPath)) {
+      fs.unlinkSync(targetPath);
+    }
+    return;
+  }
+  fs.writeFileSync(targetPath, canonicalWorkspace);
+}
+
+function stableJson(value: unknown): string {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+export type SyncStarterManifestResult = {
+  changed: boolean;
+  packageJson: PackageJson;
+  pnpmWorkspaceYaml: string | null;
+};
+
+export function syncStarterManifestFiles(options: {
+  starterPackageJsonPath: string;
+  starterPnpmWorkspacePath?: string;
+  repoRoot?: string;
+  write?: boolean;
+}): SyncStarterManifestResult {
+  const { packageJson: canonical, pnpmWorkspaceYaml } =
+    generateStandaloneChatManifest(options.repoRoot);
+
+  const starterPackageJson = JSON.parse(
+    fs.readFileSync(options.starterPackageJsonPath, "utf-8"),
+  ) as PackageJson;
+  const mergedPackageJson = mergeStarterManifest(starterPackageJson, canonical);
+
+  let workspaceChanged = false;
+  const existingWorkspace =
+    options.starterPnpmWorkspacePath &&
+    fs.existsSync(options.starterPnpmWorkspacePath)
+      ? fs.readFileSync(options.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,
+      );
+    }
+  }
+
+  return {
+    changed,
+    packageJson: mergedPackageJson,
+    pnpmWorkspaceYaml,
+  };
+}
+
+export function parseSyncStarterManifestArgs(argv: string[]): {
+  command: "merge" | "generate";
+  starterPackageJsonPath?: string;
+  starterPnpmWorkspacePath?: string;
+  write: boolean;
+  repoRoot?: string;
+} {
+  const [commandRaw, ...rest] = argv;
+  const command = commandRaw === "generate" ? "generate" : "merge";
+  let starterPackageJsonPath: string | undefined;
+  let starterPnpmWorkspacePath: string | undefined;
+  let write = false;
+  let repoRoot: string | undefined;
+
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--write") {
+      write = true;
+      continue;
+    }
+    if (arg === "--starter-package-json") {
+      starterPackageJsonPath = rest[++i];
+      continue;
+    }
+    if (arg === "--starter-pnpm-workspace") {
+      starterPnpmWorkspacePath = rest[++i];
+      continue;
+    }
+    if (arg === "--repo-root") {
+      repoRoot = rest[++i];
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  if (command === "merge" && !starterPackageJsonPath) {
+    throw new Error(
+      "merge requires --starter-package-json <path> [--starter-pnpm-workspace <path>] [--write] [--repo-root <path>]",
+    );
+  }
+
+  return {
+    command,
+    starterPackageJsonPath,
+    starterPnpmWorkspacePath,
+    write,
+    repoRoot,
+  };
+}
+
+export function runSyncStarterManifestCli(argv: string[]): number {
+  const args = parseSyncStarterManifestArgs(argv);
+
+  if (args.command === "generate") {
+    const { packageJson, pnpmWorkspaceYaml } = generateStandaloneChatManifest(
+      args.repoRoot,
+    );
+    process.stdout.write(stableJson(packageJson));
+    if (pnpmWorkspaceYaml) {
+      process.stdout.write("\n--- pnpm-workspace.yaml ---\n");
+      process.stdout.write(pnpmWorkspaceYaml);
+    }
+    return 0;
+  }
+
+  const result = syncStarterManifestFiles({
+    starterPackageJsonPath: args.starterPackageJsonPath!,
+    starterPnpmWorkspacePath: args.starterPnpmWorkspacePath,
+    repoRoot: args.repoRoot,
+    write: args.write,
+  });
+
+  if (result.changed) {
+    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.",
+    );
+    return args.write ? 0 : 1;
+  }
+
+  console.log(
+    "builder-agent-native-starter manifest already matches templates/chat.",
+  );
+  return 0;
+}
+
+const isDirectRun =
+  process.argv[1] &&
+  path.resolve(process.argv[1]) ===
+    path.resolve(fileURLToPath(import.meta.url));
+
+if (isDirectRun) {
+  const exitCode = runSyncStarterManifestCli(process.argv.slice(2));
+  process.exit(exitCode);
+}

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

@@ -103,6 +103,34 @@ function formatYValue(
   return value.toLocaleString();
 }
 
+/**
+ * Format a single metric value for display. Coerces Postgres numeric/bigint
+ * columns (returned as strings, e.g. a rate of "0.00000000000000000000") to a
+ * number so the formatter applies — SQLite returns JS numbers, so this only
+ * bites on Postgres/Neon, where the raw high-scale decimal would otherwise be
+ * dumped verbatim. A configured `valueLabels` mapping wins; a non-numeric
+ * string falls through unformatted.
+ */
+export function formatMetricValue(
+  raw: unknown,
+  formatter?: "number" | "currency" | "percent",
+  valueLabels?: Record<string, string>,
+): string {
+  const valueLabel = valueLabels?.[String(raw)];
+  if (valueLabel !== undefined) return valueLabel;
+  const numericRaw =
+    typeof raw === "number"
+      ? raw
+      : typeof raw === "string" &&
+          raw.trim() !== "" &&
+          Number.isFinite(Number(raw))
+        ? Number(raw)
+        : null;
+  return numericRaw !== null
+    ? formatYValue(numericRaw, formatter)
+    : String(raw ?? "-");
+}
+
 function parsePrometheusSeriesLabel(label: string): {
   metric: string;
   labels: Record<string, string>;
@@ -647,12 +675,11 @@ function MetricRenderer({
   } else {
     raw = row[valueCol];
   }
-  const valueLabel = panel.config?.valueLabels?.[String(raw)];
-  const value =
-    valueLabel ??
-    (typeof raw === "number"
-      ? formatYValue(raw, panel.config?.yFormatter)
-      : String(raw ?? "-"));
+  const value = formatMetricValue(
+    raw,
+    panel.config?.yFormatter,
+    panel.config?.valueLabels,
+  );
 
   return (
     <div className="flex flex-1 flex-col items-center justify-center py-2 text-center">

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -162,8 +162,14 @@ const RETRYABLE_CHUNK_UPLOAD_STATUSES = new Set([
 const SCREEN_CAPTURE_FRAME_RATE = 24;
 const SCREEN_CAPTURE_MAX_WIDTH = 1920;
 const SCREEN_CAPTURE_MAX_HEIGHT = 1080;
-const RECORDING_VIDEO_BITRATE_BPS = 1_200_000;
-const RECORDING_AUDIO_BITRATE_BPS = 96_000;
+// Capture quality for the browser MediaRecorder. We no longer shrink files
+// client-side (ffmpeg.wasm re-encode is disabled — see COMPRESSION_ENABLED in
+// `@/lib/compress`) and the upload provider streams large files directly, so we
+// capture at a crisp 1080p bitrate instead of a tight budget. 1.2 Mbps left
+// dense UI (fine text, Figma, code) visibly fuzzy; 8 Mbps keeps it sharp.
+// Dial down here if file sizes become a concern for a deployment.
+const RECORDING_VIDEO_BITRATE_BPS = 8_000_000;
+const RECORDING_AUDIO_BITRATE_BPS = 128_000;
 type CaptureSource = "screen" | "camera" | "microphone" | "unknown";
 
 const VOICE_FOCUSED_AUDIO_CONSTRAINTS: MediaTrackConstraints = {

package/corpus/templates/clips/app/routes/r.$recordingId.tsx

@@ -927,16 +927,8 @@ export default function RecordingPage() {
               <TabsTrigger value="agent" className="min-w-0 px-2 text-xs">
                 Agent
               </TabsTrigger>
-              <TabsTrigger
-                value="comments"
-                className="min-w-0 gap-1 px-2 text-xs"
-              >
+              <TabsTrigger value="comments" className="min-w-0 px-2 text-xs">
                 Activity
-                {comments.length > 0 ? (
-                  <span className="ml-0.5 rounded-full bg-accent px-1.5 text-[10px] tabular-nums">
-                    {comments.length}
-                  </span>
-                ) : null}
               </TabsTrigger>
               <TabsTrigger value="transcript" className="min-w-0 px-2 text-xs">
                 Transcript

package/corpus/templates/clips/changelog/2026-06-23-screen-recordings-now-capture-at-a-crisp-1080p-bitrate-inste.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-06-23
+---
+
+Screen recordings now capture at a crisp 1080p bitrate instead of a compressed, fuzzy one

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

@@ -5,6 +5,7 @@
   "type": "module",
   "scripts": {
     "dev": "vite build --watch",
+    "dev:hot": "tsx scripts/dev.ts",
     "build": "vite build",
     "typecheck": "tsc --noEmit",
     "package": "pnpm build && tsx scripts/package.ts"

package/corpus/templates/clips/chrome-extension/scripts/dev.ts

@@ -0,0 +1,102 @@
+/**
+ * Dev loop with auto-reload for the unpacked extension.
+ *
+ * MV3 has no built-in hot reload for unpacked extensions, so this script:
+ *   1. runs `vite build --watch` (rebuilds dist/ on every source change), and
+ *   2. serves a tiny localhost stream that emits "reload" after each rebuild.
+ *
+ * The background service worker (in dev / unpacked only) holds that stream open
+ * and calls chrome.runtime.reload() when it sees "reload" — so saving a file
+ * rebuilds AND reloads the extension with no clicking in chrome://extensions.
+ * The open fetch also keeps the worker alive while you iterate.
+ */
+import { spawn } from "node:child_process";
+import http from "node:http";
+import { watch } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const distDir = resolve(root, "dist");
+const PORT = 8123;
+
+const clients = new Set<http.ServerResponse>();
+
+const server = http.createServer((req, res) => {
+  if (req.url === "/dev-reload-stream") {
+    res.writeHead(200, {
+      "Content-Type": "text/plain; charset=utf-8",
+      "Cache-Control": "no-store",
+      "Access-Control-Allow-Origin": "*",
+      Connection: "keep-alive",
+    });
+    res.write("connected\n");
+    clients.add(res);
+    req.on("close", () => clients.delete(res));
+    return;
+  }
+  res.writeHead(404);
+  res.end();
+});
+
+server.on("error", (err) => {
+  console.error(`[clips-dev] reload server error:`, err);
+});
+
+server.listen(PORT, () => {
+  console.log(`[clips-dev] reload server → http://localhost:${PORT}`);
+  console.log(
+    `[clips-dev] load ${distDir} as an unpacked extension; it auto-reloads on rebuild.`,
+  );
+});
+
+let debounce: ReturnType<typeof setTimeout> | undefined;
+function notifyReload(): void {
+  clearTimeout(debounce);
+  debounce = setTimeout(() => {
+    if (clients.size === 0) return;
+    for (const res of clients) {
+      try {
+        res.write("reload\n");
+      } catch {
+        /* client went away */
+      }
+    }
+    console.log(
+      `[clips-dev] rebuild → reload sent to ${clients.size} client(s)`,
+    );
+  }, 250);
+}
+
+// Vite owns the actual build; we watch its output so the reload fires only after
+// dist/ is fully rewritten.
+const vite = spawn("pnpm", ["exec", "vite", "build", "--watch"], {
+  cwd: root,
+  stdio: "inherit",
+});
+vite.on("exit", (code) => {
+  console.log(`[clips-dev] vite exited (${code ?? 0})`);
+  server.close();
+  process.exit(code ?? 0);
+});
+
+let watching = false;
+function startWatchingDist(): void {
+  if (watching) return;
+  try {
+    watch(distDir, { recursive: true }, () => notifyReload());
+    watching = true;
+  } catch {
+    // dist may not exist yet on the very first run — retry shortly.
+    setTimeout(startWatchingDist, 500);
+  }
+}
+startWatchingDist();
+
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.on(signal, () => {
+    vite.kill();
+    server.close();
+    process.exit(0);
+  });
+}

package/corpus/templates/clips/chrome-extension/src/background.ts

@@ -2027,3 +2027,37 @@ chrome.debugger.onDetach.addListener((source) => {
   if (session) session.attached = false;
   tabToSession.delete(tabId);
 });
+
+// ---- Dev auto-reload (unpacked installs only) ------------------------------
+// `pnpm dev:hot` runs a localhost server that streams "reload" after each
+// rebuild; we hold the stream open and reload the extension when it fires, so
+// edits land without touching chrome://extensions. The open fetch also keeps
+// this worker alive while iterating. No-ops for packed/Web Store installs
+// (they have an update_url) and quietly retries when no dev server is running.
+function startDevHotReload(): void {
+  if ("update_url" in chrome.runtime.getManifest()) return;
+  const url = "http://localhost:8123/dev-reload-stream";
+  const connect = (): void => {
+    fetch(url, { cache: "no-store" })
+      .then(async (res) => {
+        const reader = res.body?.getReader();
+        if (!reader) {
+          setTimeout(connect, 2500);
+          return;
+        }
+        const decoder = new TextDecoder();
+        for (;;) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          if (decoder.decode(value, { stream: true }).includes("reload")) {
+            chrome.runtime.reload();
+            return;
+          }
+        }
+        setTimeout(connect, 1000);
+      })
+      .catch(() => setTimeout(connect, 2500));
+  };
+  connect();
+}
+startDevHotReload();

package/corpus/templates/clips/chrome-extension/src/offscreen.ts

@@ -417,7 +417,9 @@ async function begin(message: BeginMessage): Promise<{
   const mimeType = chooseMimeType();
   const recorder = new MediaRecorder(outputStream, {
     mimeType,
-    videoBitsPerSecond: 4_000_000,
+    // Crisp 1080p capture — matches the web/desktop recorders. Files upload
+    // directly (no client-side shrink), so we favor sharpness over a budget.
+    videoBitsPerSecond: 8_000_000,
     audioBitsPerSecond: 128_000,
   });
 

package/corpus/templates/clips/desktop/src/lib/recorder.ts

@@ -88,9 +88,13 @@ const LIVE_UPLOAD_CHUNK_MS = 1_000;
 const CLOUD_CAPTURE_FRAME_RATE = 24;
 const CLOUD_CAPTURE_MAX_WIDTH = 1920;
 const CLOUD_CAPTURE_MAX_HEIGHT = 1080;
-const CLOUD_RECORDING_MAX_LONG_EDGE = 1280;
-const CLOUD_RECORDING_VIDEO_BITRATE_BPS = 900_000;
-const CLOUD_RECORDING_AUDIO_BITRATE_BPS = 96_000;
+// Crisp capture for the desktop browser MediaRecorder fallback. Files are no
+// longer shrunk client-side and the upload provider streams large files, so we
+// keep full 1080p (was downscaled to a 1280 long edge) and a sharp bitrate (was
+// 900 kbps, which left UI and text fuzzy). Dial down if file size matters.
+const CLOUD_RECORDING_MAX_LONG_EDGE = 1920;
+const CLOUD_RECORDING_VIDEO_BITRATE_BPS = 8_000_000;
+const CLOUD_RECORDING_AUDIO_BITRATE_BPS = 128_000;
 
 function isMacPlatform(): boolean {
   if (typeof navigator === "undefined") return false;

package/corpus/templates/clips/desktop/src-tauri/src/native_screen.rs

@@ -38,9 +38,9 @@ const COMPRESSION_ENABLED: bool = true;
 const TRANSCODE_THRESHOLD_BYTES: u64 = 24 * 1024 * 1024;
 const TARGET_UPLOAD_BYTES: u64 = 18 * 1024 * 1024;
 // Mirror of the shared `MAX_UPLOAD_BYTES` limit (see
-// `templates/clips/shared/upload-limits.ts`). Same default (256 MB) and same
+// `templates/clips/shared/upload-limits.ts`). Same default (2 GB) and same
 // env var (CLIPS_MAX_UPLOAD_BYTES) so desktop and web stay in lockstep.
-const DEFAULT_MAX_UPLOAD_BYTES: u64 = 256 * 1024 * 1024;
+const DEFAULT_MAX_UPLOAD_BYTES: u64 = 2 * 1024 * 1024 * 1024;
 const MIN_TRANSCODE_VIDEO_RATE_KBPS: u32 = 350;
 const TRANSCODE_RATE_LIMIT_OVERHEAD_KBPS: f64 = 64.0;
 const TRANSCODE_FRAME_RATE_LIMIT: u32 = 30;

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

@@ -405,7 +405,15 @@ export default defineEventHandler(async (event: H3Event) => {
         return loomEmbedResponse(embedUrl);
       }
 
-      const blob = await readAppState(`recording-blob-${recordingId}`);
+      // The `recording-blob-*` fallback only exists for local/dev recordings
+      // (production uses provider storage), and `readAppState` THROWS when there
+      // is no authenticated identity in context. An anonymous viewer of a public
+      // clip therefore has no blob to read anyway — swallow the missing-context
+      // error and fall through to the provider media URL instead of surfacing an
+      // unhandled 500 ("Could not start playback. Try again." in the player).
+      const blob = await readAppState(`recording-blob-${recordingId}`).catch(
+        () => null,
+      );
       const b64 = typeof blob?.data === "string" ? blob.data : null;
       const rangeHeader = getRequestHeader(event, "range");
 

package/corpus/templates/clips/shared/upload-limits.ts

@@ -11,8 +11,11 @@
  * `desktop/src-tauri/src/native_screen.rs` (same env var, same default).
  */
 
-/** Default maximum upload size: 256 MB. */
-export const DEFAULT_MAX_UPLOAD_BYTES = 256 * 1024 * 1024;
+/** Default maximum upload size: 2 GB. The upload provider streams large files
+ * directly, so this is a generous safety ceiling rather than a hard product
+ * limit. It mainly bounds how long a high-bitrate (crisp 1080p) recording can
+ * run before it must be split — ~34 min at the 8 Mbps capture default. */
+export const DEFAULT_MAX_UPLOAD_BYTES = 2 * 1024 * 1024 * 1024;
 
 /** Env var that overrides the upload ceiling, in bytes. */
 export const MAX_UPLOAD_BYTES_ENV = "CLIPS_MAX_UPLOAD_BYTES";