@jami-studio/core 0.92.35 → 0.92.37

package/corpus/README.md

@@ -27,5 +27,5 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 2158
+- core files: 2159
 - template files: 5117

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.92.37
+
+### Patch Changes
+
+- c8694f1: Workspace deploy now caches per-app builds by content hash: unchanged apps (sources, workspace deps, lockfile, invocation env, builder version) reuse their previous build output instead of rebuilding. Disable with `--no-build-cache` or `AGENT_NATIVE_WORKSPACE_BUILD_CACHE=0`.
+
+## 0.92.36
+
+### Patch Changes
+
+- dc8c05b: Serverless route discovery now mounts TOP-LEVEL `server/routes/*` files (e.g. analytics `track.post.ts` → `POST /track`) in the generated worker entry — previously only the `/api` and `/_agent-native` subtrees were scanned, so ingest routes living outside `/api` 404'd on every serverless deploy. Page catch-alls (`[...page].get.ts`) stay unmounted (the static app shell owns page serving), and non-api subdirectories are unchanged.
+
 ## 0.92.35
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.92.35",
+  "version": "0.92.37",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/studio-jami/jami-studio#readme",
   "bugs": {

package/corpus/core/src/deploy/route-discovery.ts

@@ -88,15 +88,41 @@ export interface DiscoveredRoute {
 
 /**
  * Discover all API routes in a project's server/routes/ directory.
+ *
+ * Scans the `/api` and `/_agent-native` subtrees plus TOP-LEVEL route files
+ * (e.g. analytics `track.post.ts` → `POST /track`, an ingest endpoint that
+ * deliberately lives outside `/api`). Top-level catch-alls (`[...page].get.ts`
+ * — the SSR page fallback every template ships) are excluded: on serverless
+ * workers pages are served by the static app shell, and mounting the
+ * catch-all would shadow it.
  */
 export async function discoverApiRoutes(
   cwd: string,
 ): Promise<DiscoveredRoute[]> {
+  const fs = await getFs();
+  const routesDir = path.join(cwd, "server/routes");
   const apiDir = path.join(cwd, "server/routes/api");
   const agentNativeDir = path.join(cwd, "server/routes/_agent-native");
+  const topLevelFiles: string[] = [];
+  try {
+    if (fs.existsSync(routesDir)) {
+      for (const entry of fs.readdirSync(routesDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) continue;
+        if (!entry.name.endsWith(".ts") && !entry.name.endsWith(".js")) {
+          continue;
+        }
+        // Skip page catch-alls — the static shell owns page serving.
+        if (entry.name.startsWith("[...")) continue;
+        topLevelFiles.push(entry.name);
+      }
+    }
+  } catch {
+    // Edge runtime — no filesystem.
+  }
   const routeFiles = [
     ...(await discoverFiles(apiDir, "api")),
     ...(await discoverFiles(agentNativeDir, "_agent-native")),
+    ...topLevelFiles,
   ];
   const routes: DiscoveredRoute[] = [];
 

package/corpus/core/src/deploy/workspace-build-cache.ts

@@ -0,0 +1,305 @@
+/**
+ * Content-hash build cache for `agent-native deploy` workspace builds.
+ *
+ * Rebuilding every app on every workspace deploy is pure waste when only a
+ * few apps changed. Each app's build is a deterministic function of:
+ *
+ *   1. The app directory's source files (excluding build outputs + deps).
+ *   2. The workspace-local packages it depends on via `workspace:*`.
+ *   3. The root lockfile (captures every registry dependency version,
+ *      including the framework runtime itself).
+ *   4. The environment the build is invoked with: the deploy preset, the
+ *      computed per-app env block (base path, audience, workspace manifest,
+ *      gateway URL, ...) and any ambient env Vite/Nitro can bake into the
+ *      bundle (`VITE_*`, `AGENT_NATIVE_*`, `WORKSPACE_*`, ...).
+ *   5. The version of this package doing the building.
+ *
+ * When all of that is byte-identical to the previous run AND the app's
+ * previous build output still exists on disk, the build is skipped and the
+ * existing output is reused. The workspace output assembly (copy into
+ * dist/, manifests, dedupe, routing) always runs fresh — it is cheap and
+ * keeps the artifact deterministic.
+ *
+ * Safety posture: a false MISS costs one redundant rebuild; a false HIT
+ * ships a stale artifact. Every choice below prefers false misses — full
+ * content hashing (no mtimes), lockfile-wide invalidation, and the entire
+ * invocation env block folded into the key.
+ *
+ * Opt out with `--no-build-cache` or AGENT_NATIVE_WORKSPACE_BUILD_CACHE=0.
+ */
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+/** Directories inside an app that are build outputs or dependencies — never
+ * build inputs. Everything else in the app dir participates in the hash. */
+const EXCLUDED_APP_DIRS = new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".output",
+  ".deploy-tmp",
+  ".netlify",
+  ".vercel",
+  ".react-router",
+  ".cache",
+  ".turbo",
+  ".git",
+]);
+
+/** Ambient process.env prefixes that can be baked into app bundles. */
+const ENV_PREFIXES = ["VITE_", "AGENT_NATIVE_", "WORKSPACE_", "NETLIFY_"];
+const ENV_EXACT_KEYS = [
+  "APP_URL",
+  "BETTER_AUTH_URL",
+  "DATABASE_URL",
+  "NITRO_PRESET",
+  "NODE_ENV",
+];
+
+const STAMP_DIR = path.join("node_modules", ".cache", "agent-native");
+const STAMP_FILE = "workspace-build.json";
+
+export interface WorkspaceBuildCacheOptions {
+  workspaceRoot: string;
+  appDir: string;
+  app: string;
+  preset: string;
+  /** The exact env block the app build is invoked with (delta over
+   * process.env computed by the deploy orchestrator). */
+  buildEnv: Record<string, string | undefined>;
+  /** Version of the framework package performing the build. */
+  builderVersion: string;
+}
+
+export function isWorkspaceBuildCacheEnabled(rawArgs: string[]): boolean {
+  if (rawArgs.includes("--no-build-cache")) return false;
+  const env = process.env.AGENT_NATIVE_WORKSPACE_BUILD_CACHE;
+  if (env === "0" || env === "false") return false;
+  return true;
+}
+
+/** Compute the cache key for one app build. Returns null when hashing is not
+ * possible (treat as cache miss — never as a hit). */
+export function computeWorkspaceAppBuildHash(
+  opts: WorkspaceBuildCacheOptions,
+): string | null {
+  try {
+    const hash = crypto.createHash("sha256");
+    hash.update(`builder:${opts.builderVersion}\0`);
+    hash.update(`preset:${opts.preset}\0`);
+
+    // 1. App sources.
+    hashDirInto(hash, opts.appDir, opts.appDir);
+
+    // 2. workspace:* dependency packages (source-level inputs the lockfile
+    //    does not pin).
+    for (const depDir of resolveWorkspaceDepDirs(
+      opts.workspaceRoot,
+      opts.appDir,
+    )) {
+      hash.update(`workspace-dep:${path.basename(depDir)}\0`);
+      hashDirInto(hash, depDir, depDir);
+    }
+
+    // 3. Root lockfile — pins every registry dependency (framework runtime
+    //    included), so a core bump or any dep change invalidates all apps.
+    for (const lock of ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"]) {
+      const lockPath = path.join(opts.workspaceRoot, lock);
+      if (fs.existsSync(lockPath)) {
+        hash.update(`lock:${lock}\0`);
+        hash.update(fs.readFileSync(lockPath));
+        hash.update("\0");
+      }
+    }
+
+    // 4. Invocation env: the computed per-app block plus ambient bakeable
+    //    env. Values are hashed, never stored.
+    const envEntries: string[] = [];
+    for (const [key, value] of Object.entries(opts.buildEnv)) {
+      if (value !== undefined) envEntries.push(`${key}=${value}`);
+    }
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value === undefined) continue;
+      if (key in opts.buildEnv) continue; // computed block wins
+      const relevant =
+        ENV_EXACT_KEYS.includes(key) ||
+        ENV_PREFIXES.some((p) => key.startsWith(p));
+      if (relevant) envEntries.push(`${key}=${value}`);
+    }
+    envEntries.sort();
+    hash.update(`env:${envEntries.join("\n")}\0`);
+
+    return hash.digest("hex");
+  } catch {
+    return null;
+  }
+}
+
+/** True when the app's previous build can be reused as-is. */
+export function workspaceAppBuildCacheHit(
+  opts: WorkspaceBuildCacheOptions,
+  hashValue: string | null,
+): boolean {
+  if (!hashValue) return false;
+  const stamp = readStamp(opts.appDir);
+  if (!stamp || stamp.hash !== hashValue || stamp.preset !== opts.preset) {
+    return false;
+  }
+  return requiredOutputsExist(opts.appDir, opts.preset);
+}
+
+/** Record a successful build so the next identical run can skip it. */
+export function writeWorkspaceAppBuildStamp(
+  opts: WorkspaceBuildCacheOptions,
+  hashValue: string | null,
+): void {
+  if (!hashValue) return;
+  try {
+    const dir = path.join(opts.appDir, STAMP_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, STAMP_FILE),
+      JSON.stringify(
+        {
+          hash: hashValue,
+          preset: opts.preset,
+          builderVersion: opts.builderVersion,
+          createdAt: new Date().toISOString(),
+        },
+        null,
+        2,
+      ),
+    );
+  } catch {
+    // Best-effort: a missing stamp only costs a rebuild next time.
+  }
+}
+
+function readStamp(
+  appDir: string,
+): { hash: string; preset: string } | null {
+  try {
+    const raw = fs.readFileSync(
+      path.join(appDir, STAMP_DIR, STAMP_FILE),
+      "utf-8",
+    );
+    const parsed = JSON.parse(raw) as { hash?: unknown; preset?: unknown };
+    if (typeof parsed.hash !== "string" || typeof parsed.preset !== "string") {
+      return null;
+    }
+    return { hash: parsed.hash, preset: parsed.preset };
+  } catch {
+    return null;
+  }
+}
+
+function requiredOutputsExist(appDir: string, preset: string): boolean {
+  if (preset === "vercel") {
+    return fs.existsSync(path.join(appDir, ".vercel", "output"));
+  }
+  const buildOut =
+    fs.existsSync(path.join(appDir, "dist")) ||
+    fs.existsSync(path.join(appDir, ".output"));
+  if (!buildOut) return false;
+  if (preset === "netlify") {
+    return fs.existsSync(
+      path.join(appDir, ".netlify", "functions-internal", "server"),
+    );
+  }
+  return true;
+}
+
+/** Deterministically hash every build-input file under `dir`. */
+function hashDirInto(
+  hash: crypto.Hash,
+  dir: string,
+  rootDir: string,
+): void {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.name.startsWith(".DS_")) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (dir === rootDir && EXCLUDED_APP_DIRS.has(entry.name)) continue;
+      // Nested node_modules (e.g. inside checked-in fixtures) are still deps.
+      if (entry.name === "node_modules") continue;
+      hashDirInto(hash, full, rootDir);
+    } else if (entry.isFile()) {
+      const rel = path.relative(rootDir, full).split(path.sep).join("/");
+      hash.update(`f:${rel}\0`);
+      try {
+        hash.update(fs.readFileSync(full));
+      } catch {
+        hash.update("<unreadable>");
+      }
+      hash.update("\0");
+    }
+    // Symlinks and other entry types are skipped: their targets are either
+    // covered elsewhere (workspace deps) or not build inputs.
+  }
+}
+
+/** Resolve the app's `workspace:*` dependencies to their package dirs. */
+function resolveWorkspaceDepDirs(
+  workspaceRoot: string,
+  appDir: string,
+): string[] {
+  const dirs: string[] = [];
+  let pkg: {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+  try {
+    pkg = JSON.parse(
+      fs.readFileSync(path.join(appDir, "package.json"), "utf-8"),
+    );
+  } catch {
+    return dirs;
+  }
+  const workspaceDepNames = Object.entries({
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+  })
+    .filter(([, spec]) => typeof spec === "string" && spec.startsWith("workspace:"))
+    .map(([name]) => name);
+  if (workspaceDepNames.length === 0) return dirs;
+
+  const packagesDir = path.join(workspaceRoot, "packages");
+  let candidates: string[] = [];
+  try {
+    candidates = fs
+      .readdirSync(packagesDir, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => path.join(packagesDir, e.name));
+  } catch {
+    return dirs;
+  }
+  const byName = new Map<string, string>();
+  for (const candidate of candidates) {
+    try {
+      const name = (
+        JSON.parse(
+          fs.readFileSync(path.join(candidate, "package.json"), "utf-8"),
+        ) as { name?: string }
+      ).name;
+      if (typeof name === "string") byName.set(name, candidate);
+    } catch {
+      // skip unreadable packages
+    }
+  }
+  for (const depName of workspaceDepNames.sort()) {
+    const dir = byName.get(depName);
+    if (dir) dirs.push(dir);
+    // Unresolvable workspace deps fall back to lockfile coverage; the sorted
+    // dep-name list itself is not hashed separately because package.json is
+    // already part of the app-source hash.
+  }
+  return dirs;
+}

package/corpus/core/src/deploy/workspace-deploy.ts

@@ -17,9 +17,16 @@
 import { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
+import { fileURLToPath } from "url";
 
 import { AGENT_CHAT_PROCESS_RUN_PATH } from "../agent/durable-background.js";
 import { findWorkspaceRoot } from "../scripts/utils.js";
+import {
+  computeWorkspaceAppBuildHash,
+  isWorkspaceBuildCacheEnabled,
+  workspaceAppBuildCacheHit,
+  writeWorkspaceAppBuildStamp,
+} from "./workspace-build-cache.js";
 import {
   DEFAULT_WORKSPACE_APP_AUDIENCE,
   normalizeWorkspaceAppAudience,
@@ -64,6 +71,19 @@ const WORKSPACE_APPS_MANIFEST_DIR = ".agent-native";
 const WORKSPACE_APPS_MANIFEST_FILE = "workspace-apps.json";
 const VERCEL_OUTPUT_DIR = ".vercel/output";
 
+// Version of this package — folds into the build-cache key so upgrading the
+// framework invalidates every cached app build.
+let BUILDER_VERSION = "unknown";
+try {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  // dist/deploy/workspace-deploy.js → ../../package.json
+  BUILDER_VERSION = (
+    JSON.parse(
+      fs.readFileSync(path.resolve(__dirname, "../../package.json"), "utf-8"),
+    ) as { version?: string }
+  ).version ?? "unknown";
+} catch {}
+
 interface WorkspaceAppManifestEntry {
   id: string;
   name: string;
@@ -152,9 +172,24 @@ export async function runWorkspaceDeploy(
     `[workspace-deploy] Building ${apps.length} app(s) for preset=${preset}`,
   );
 
+  const buildCacheEnabled = isWorkspaceBuildCacheEnabled(rawArgs);
+  if (!buildCacheEnabled) {
+    console.log(
+      `[workspace-deploy] Build cache disabled — rebuilding every app.`,
+    );
+  }
+  let cachedCount = 0;
   const execFile = opts.execFile ?? execFileSync;
   for (const app of apps) {
-    buildOneApp(workspaceRoot, app, preset, execFile, workspaceApps);
+    const skipped = buildOneApp(
+      workspaceRoot,
+      app,
+      preset,
+      execFile,
+      workspaceApps,
+      buildCacheEnabled,
+    );
+    if (skipped) cachedCount++;
     moveAppBuildIntoWorkspaceOutput(
       workspaceRoot,
       app,
@@ -164,6 +199,11 @@ export async function runWorkspaceDeploy(
       workspaceApps,
     );
   }
+  if (buildCacheEnabled && cachedCount > 0) {
+    console.log(
+      `[workspace-deploy] Build cache: reused ${cachedCount}/${apps.length} unchanged app build(s), rebuilt ${apps.length - cachedCount}.`,
+    );
+  }
   writeWorkspaceAppManifests(
     workspaceRoot,
     distDir,
@@ -212,7 +252,8 @@ function buildOneApp(
   preset: WorkspaceDeployPreset,
   execFile: typeof execFileSync,
   workspaceApps: WorkspaceAppManifestEntry[],
-): void {
+  buildCacheEnabled: boolean,
+): boolean {
   const appDir = path.join(workspaceRoot, "apps", app);
   const workspaceAppAudience = workspaceAppAudienceForApp(workspaceApps, app);
   const workspaceAppRouteAccess = workspaceAppRouteAccessForApp(
@@ -277,6 +318,27 @@ function buildOneApp(
       env.DATABASE_URL;
   }
 
+  // Content-hash cache: when the app's sources, workspace deps, lockfile,
+  // and invocation env are byte-identical to the previous successful build
+  // (and its output still exists), reuse it instead of rebuilding.
+  const cacheOpts = {
+    workspaceRoot,
+    appDir,
+    app,
+    preset,
+    buildEnv: buildCacheEnvDelta(env),
+    builderVersion: BUILDER_VERSION,
+  };
+  const buildHash = buildCacheEnabled
+    ? computeWorkspaceAppBuildHash(cacheOpts)
+    : null;
+  if (buildCacheEnabled && workspaceAppBuildCacheHit(cacheOpts, buildHash)) {
+    console.log(
+      `[workspace-deploy] ${app} unchanged — reusing cached build (base=/${app}, preset=${preset})`,
+    );
+    return true;
+  }
+
   console.log(
     `[workspace-deploy] Building ${app} (base=/${app}, preset=${preset})`,
   );
@@ -298,7 +360,10 @@ function buildOneApp(
         env,
         stdio: "inherit",
       });
-      return;
+      if (buildCacheEnabled) {
+        writeWorkspaceAppBuildStamp(cacheOpts, buildHash);
+      }
+      return false;
     } catch (error) {
       const status = (error as { status?: number | null })?.status ?? null;
       const isNativeCrash =
@@ -1123,6 +1188,19 @@ function netlifyFunctionsDir(workspaceRoot: string): string {
   return path.join(workspaceRoot, ".netlify", "functions-internal");
 }
 
+/** The per-app build env is `{...process.env, ...computed}` — only the
+ * computed delta belongs in the cache key (ambient env is covered by the
+ * cache module's own prefix filter, machine noise like PATH stays out). */
+function buildCacheEnvDelta(
+  env: NodeJS.ProcessEnv,
+): Record<string, string | undefined> {
+  const delta: Record<string, string | undefined> = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (process.env[key] !== value) delta[key] = value;
+  }
+  return delta;
+}
+
 function cleanAppBuildOutputs(appDir: string): void {
   // .deploy-tmp: a crashed prior per-app build leaves partial artifacts that
   // silently poison the next build for that app (observed on Windows: stale

package/corpus/templates/calendar/app/root.tsx

@@ -239,7 +239,10 @@ export default function Root() {
     }),
   );
   const location = useLocation();
-  const loaderData = useLoaderData<typeof loader>();
+  // Static-shell serverless deployments never run the root loader (the
+  // client manifest strips hasLoader), so loader data can be null at
+  // hydration — fall back exactly like Layout does.
+  const loaderData = useLoaderData<typeof loader>() ?? DEFAULT_LOADER_DATA;
   const isPublicPath = isPublicBookingPath(location.pathname);
 
   return (

package/corpus/templates/clips/app/root.tsx

@@ -379,7 +379,10 @@ function AppContent() {
  */
 export default function Root() {
   const location = useLocation();
-  const loaderData = useLoaderData<typeof loader>();
+  // Static-shell serverless deployments never run the root loader (the
+  // client manifest strips hasLoader), so loader data can be null at
+  // hydration — fall back exactly like Layout does.
+  const loaderData = useLoaderData<typeof loader>() ?? DEFAULT_LOADER_DATA;
   const [queryClient] = useState(() => createAgentNativeQueryClient());
   return (
     <AppToolkitProvider>

package/corpus/templates/content/app/root.tsx

@@ -547,7 +547,10 @@ export default function Root() {
   const [queryClient] = useState(() => createAgentNativeQueryClient());
   const [cmdkOpen, setCmdkOpen] = useState(false);
   const location = useLocation();
-  const loaderData = useLoaderData<typeof loader>();
+  // Static-shell serverless deployments never run the root loader (the
+  // client manifest strips hasLoader), so loader data can be null at
+  // hydration — fall back exactly like Layout does.
+  const loaderData = useLoaderData<typeof loader>() ?? DEFAULT_LOADER_DATA;
   useCommandMenuShortcut(
     useCallback(() => setCmdkOpen(true), []),
     {

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/route-discovery.d.ts

@@ -25,6 +25,13 @@ export interface DiscoveredRoute {
 }
 /**
  * Discover all API routes in a project's server/routes/ directory.
+ *
+ * Scans the `/api` and `/_agent-native` subtrees plus TOP-LEVEL route files
+ * (e.g. analytics `track.post.ts` → `POST /track`, an ingest endpoint that
+ * deliberately lives outside `/api`). Top-level catch-alls (`[...page].get.ts`
+ * — the SSR page fallback every template ships) are excluded: on serverless
+ * workers pages are served by the static app shell, and mounting the
+ * catch-all would shadow it.
  */
 export declare function discoverApiRoutes(cwd: string): Promise<DiscoveredRoute[]>;
 /**

package/dist/deploy/route-discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-discovery.d.ts","sourceRoot":"","sources":["../../src/deploy/route-discovery.ts"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,IAAI,CA2BP;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,MAAM,SAAK,GACV,OAAO,CAAC,MAAM,EAAE,CAAC,CAkBnB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,eAAe,EAAE,CAAC,CAoB5B;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAapE;AASD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAY1D,CAAC;AAWF,MAAM,WAAW,gBAAgB;IAC/B,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAaD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GACd,KAAK,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAmB3C;AAyKD;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAoB7B;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAmB7E"}
+{"version":3,"file":"route-discovery.d.ts","sourceRoot":"","sources":["../../src/deploy/route-discovery.ts"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,IAAI,CA2BP;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,MAAM,SAAK,GACV,OAAO,CAAC,MAAM,EAAE,CAAC,CAkBnB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,eAAe,EAAE,CAAC,CAuC5B;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAapE;AASD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAY1D,CAAC;AAWF,MAAM,WAAW,gBAAgB;IAC/B,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAaD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GACd,KAAK,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAmB3C;AAyKD;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAoB7B;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAmB7E"}

package/dist/deploy/route-discovery.js

@@ -67,13 +67,42 @@ export async function discoverFiles(dir, prefix = "") {
 }
 /**
  * Discover all API routes in a project's server/routes/ directory.
+ *
+ * Scans the `/api` and `/_agent-native` subtrees plus TOP-LEVEL route files
+ * (e.g. analytics `track.post.ts` → `POST /track`, an ingest endpoint that
+ * deliberately lives outside `/api`). Top-level catch-alls (`[...page].get.ts`
+ * — the SSR page fallback every template ships) are excluded: on serverless
+ * workers pages are served by the static app shell, and mounting the
+ * catch-all would shadow it.
  */
 export async function discoverApiRoutes(cwd) {
+    const fs = await getFs();
+    const routesDir = path.join(cwd, "server/routes");
     const apiDir = path.join(cwd, "server/routes/api");
     const agentNativeDir = path.join(cwd, "server/routes/_agent-native");
+    const topLevelFiles = [];
+    try {
+        if (fs.existsSync(routesDir)) {
+            for (const entry of fs.readdirSync(routesDir, { withFileTypes: true })) {
+                if (entry.isDirectory())
+                    continue;
+                if (!entry.name.endsWith(".ts") && !entry.name.endsWith(".js")) {
+                    continue;
+                }
+                // Skip page catch-alls — the static shell owns page serving.
+                if (entry.name.startsWith("[..."))
+                    continue;
+                topLevelFiles.push(entry.name);
+            }
+        }
+    }
+    catch {
+        // Edge runtime — no filesystem.
+    }
     const routeFiles = [
         ...(await discoverFiles(apiDir, "api")),
         ...(await discoverFiles(agentNativeDir, "_agent-native")),
+        ...topLevelFiles,
     ];
     const routes = [];
     for (const relFile of routeFiles) {