npm - @jami-studio/core - Versions diffs - 0.92.36 → 0.92.38 - Mend

@jami-studio/core 0.92.36 → 0.92.38

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/corpus/README.md +2 -2
package/corpus/core/CHANGELOG.md +12 -0
package/corpus/core/package.json +1 -1
package/corpus/core/src/deploy/build.ts +106 -13
package/corpus/core/src/deploy/workspace-build-cache.ts +305 -0
package/corpus/core/src/deploy/workspace-deploy.ts +81 -3
package/corpus/core/src/vite/client.ts +8 -5
package/corpus/templates/assets/changelog/2026-07-12-image-uploads-now-work-on-serverless-runtimes-without-native.md +6 -0
package/corpus/templates/assets/server/lib/image-processing.ts +184 -24
package/corpus/templates/calendar/app/root.tsx +4 -1
package/corpus/templates/clips/app/root.tsx +4 -1
package/corpus/templates/content/app/root.tsx +4 -1
package/dist/deploy/build.d.ts.map +1 -1
package/dist/deploy/build.js +105 -12
package/dist/deploy/build.js.map +1 -1
package/dist/deploy/workspace-build-cache.d.ts +20 -0
package/dist/deploy/workspace-build-cache.d.ts.map +1 -0
package/dist/deploy/workspace-build-cache.js +258 -0
package/dist/deploy/workspace-build-cache.js.map +1 -0
package/dist/deploy/workspace-deploy.d.ts.map +1 -1
package/dist/deploy/workspace-deploy.js +56 -3
package/dist/deploy/workspace-deploy.js.map +1 -1
package/dist/vite/client.d.ts.map +1 -1
package/dist/vite/client.js +8 -5
package/dist/vite/client.js.map +1 -1
package/package.json +1 -1

package/corpus/README.md CHANGED Viewed

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

package/corpus/core/CHANGELOG.md CHANGED Viewed

@@ -1,5 +1,17 @@
 # @agent-native/core
+## 0.92.38
+### Patch Changes
+- 7e2841f: Cloudflare Pages static shell: render the real landing page instead of the hydration-mismatching manifest fallback — resolve framework-transitive packages (yjs, prosemirror) via module resolution hooks, follow same-origin index redirects with mount-prefix stripping, try both prefixed and unprefixed route shapes, and make the SSR heavy-lib stub callable/constructible so module-scope `new PluginKey(...)` in stubbed client code cannot crash the shell render. Manifest-fallback shells now emit `<html lang="en-US" dir="ltr" data-locale="en-US">` when the root route has a loader, matching the default hydration state. Fixes React #418 hydration errors on served workspace apps.
+## 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

package/corpus/core/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.92.36",
+  "version": "0.92.38",
   "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/build.ts CHANGED Viewed

@@ -1759,8 +1759,15 @@ export function generateCloudflarePagesStaticShellFromManifest(
   const encodedInitialState = rootRoute.hasLoader
     ? DEFAULT_ROOT_LOADER_REACT_ROUTER_TURBO_STREAM
     : EMPTY_REACT_ROUTER_TURBO_STREAM;
-  return `<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no"/><link rel="manifest" href="/manifest.json"/><link rel="icon" type="image/svg+xml" href="/favicon.svg"/>${modulePreloads}${stylesheets}</head><body><div style="display:flex;align-items:center;justify-content:center;height:100vh;width:100%"><svg role="status" aria-label="Loading" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="animation:an-spin 1s linear infinite;opacity:0.7"><path d="M21 12a9 9 0 1 1-6.219-8.56"></path></svg><style>@keyframes an-spin { to { transform: rotate(360deg) } } @media (prefers-color-scheme: dark) { html { background: #09090b; color: #fafafa } }</style></div><script>window.__reactRouterContext = ${JSON.stringify(context)};window.__reactRouterContext.stream = new ReadableStream({start(controller){window.__reactRouterContext.streamController = controller;}}).pipeThrough(new TextEncoderStream());</script><script type="module" async="">${routeModuleScript}</script><!--$--><script>window.__reactRouterContext.streamController.enqueue(${JSON.stringify(encodedInitialState)});</script><!--$--><script>window.__reactRouterContext.streamController.close();</script><!--/$--><!--/$--></body></html>`;
+  // Match the <html> attributes the root route renders during hydration with
+  // the embedded default root-loader state (locale/dir), so recovering from
+  // the fallback shell does not add an attribute mismatch on top of the
+  // structural one.
+  const htmlTag = rootRoute.hasLoader
+    ? '<html lang="en-US" dir="ltr" data-locale="en-US">'
+    : '<html lang="en">';
+  return `<!DOCTYPE html>${htmlTag}<head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no"/><link rel="manifest" href="/manifest.json"/><link rel="icon" type="image/svg+xml" href="/favicon.svg"/>${modulePreloads}${stylesheets}</head><body><div style="display:flex;align-items:center;justify-content:center;height:100vh;width:100%"><svg role="status" aria-label="Loading" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="animation:an-spin 1s linear infinite;opacity:0.7"><path d="M21 12a9 9 0 1 1-6.219-8.56"></path></svg><style>@keyframes an-spin { to { transform: rotate(360deg) } } @media (prefers-color-scheme: dark) { html { background: #09090b; color: #fafafa } }</style></div><script>window.__reactRouterContext = ${JSON.stringify(context)};window.__reactRouterContext.stream = new ReadableStream({start(controller){window.__reactRouterContext.streamController = controller;}}).pipeThrough(new TextEncoderStream());</script><script type="module" async="">${routeModuleScript}</script><!--$--><script>window.__reactRouterContext.streamController.enqueue(${JSON.stringify(encodedInitialState)});</script><!--$--><script>window.__reactRouterContext.streamController.close();</script><!--/$--><!--/$--></body></html>`;
 }
 function writeCloudflarePagesStaticShell({
@@ -1784,32 +1791,118 @@ function writeCloudflarePagesStaticShell({
     renderScript,
     `
 import fs from "node:fs";
-import { createRequire } from "node:module";
+import Module, { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
 const cwd = ${JSON.stringify(cwd)};
 const serverEntry = ${JSON.stringify(serverEntry)};
 const outFile = ${JSON.stringify(outFile)};
 const basePath = ${JSON.stringify(basePath)};
+// The framework package's own module URL: bundled server chunks can import
+// packages (yjs, prosemirror-*) that are transitive framework dependencies
+// and not resolvable from the app directory under strict pnpm layouts. When
+// app-relative resolution fails, retry from the framework's own context.
+const frameworkParentUrl = ${JSON.stringify(import.meta.url)};
+if (typeof Module.registerHooks === "function") {
+  Module.registerHooks({
+    resolve(specifier, context, nextResolve) {
+      try {
+        return nextResolve(specifier, context);
+      } catch (error) {
+        if (context?.parentURL && context.parentURL !== frameworkParentUrl) {
+          try {
+            return nextResolve(specifier, { ...context, parentURL: frameworkParentUrl });
+          } catch {}
+        }
+        throw error;
+      }
+    },
+  });
+}
 const requireFromApp = createRequire(cwd + "/package.json");
 const reactRouterEntry = requireFromApp.resolve("react-router");
 const { createRequestHandler } = await import(pathToFileURL(reactRouterEntry).href);
 const serverBuild = await import(pathToFileURL(serverEntry).href);
 const handler = createRequestHandler(serverBuild, "production");
-const pathname = basePath ? basePath + "/" : "/";
-const response = await handler(
-  new Request(new URL(pathname, "https://agent-native.local"), {
-    headers: { "X-React-Router-SPA-Mode": "yes" },
-  }),
-);
-const html = await response.text();
-if (!html || !html.includes("__reactRouterContext") || !html.includes("entry.client")) {
-  throw new Error("React Router did not render a usable Cloudflare Pages static shell");
+const origin = "https://agent-native.local";
+const normalizedBase = basePath ? basePath.replace(/\\/+$/, "") : "";
+function isUsable(html) {
+  return Boolean(
+    html && html.includes("__reactRouterContext") && html.includes("entry.client"),
+  );
 }
-fs.writeFileSync(outFile, html);
+// Render a path, following same-origin redirects (index routes commonly
+// redirect "/" to the real landing page). Server builds compiled with an
+// unprefixed router basename ("/") emit redirect targets that still carry
+// the mount prefix — strip it before re-requesting.
+async function renderPath(startPath) {
+  let pathname = startPath;
+  let response;
+  for (let hop = 0; hop < 5; hop++) {
+    response = await handler(
+      new Request(new URL(pathname, origin), {
+        headers: { "X-React-Router-SPA-Mode": "yes" },
+      }),
+    );
+    if (response.status < 300 || response.status >= 400) break;
+    const location = response.headers.get("location");
+    if (!location) break;
+    const target = new URL(location, new URL(pathname, origin));
+    if (target.origin !== origin) break;
+    let nextPath = target.pathname;
+    if (
+      normalizedBase &&
+      (nextPath === normalizedBase || nextPath.startsWith(normalizedBase + "/")) &&
+      !(startPath === normalizedBase + "/" || startPath.startsWith(normalizedBase + "/"))
+    ) {
+      nextPath = nextPath.slice(normalizedBase.length) || "/";
+    }
+    if (nextPath === pathname) break;
+    pathname = nextPath;
+  }
+  const html = await response.text();
+  return { pathname, status: response.status, html };
+}
+// Route matching varies per template: some builds register routes under the
+// mount prefix, others compile with basename "/" and rely on the worker
+// entry stripping the prefix. Try both shapes and prefer a 2xx render;
+// otherwise keep the first usable render of any status (apps without an
+// index route ship their root-boundary render as the shell).
+const candidates = normalizedBase ? [normalizedBase + "/", "/"] : ["/"];
+let best = null;
+for (const candidate of candidates) {
+  let result;
+  try {
+    result = await renderPath(candidate);
+  } catch (error) {
+    console.warn("[deploy] Static shell render threw at " + candidate + ": " + (error && error.message ? error.message : error));
+    continue;
+  }
+  if (!isUsable(result.html)) continue;
+  if (result.status >= 200 && result.status < 300) {
+    best = result;
+    break;
+  }
+  if (!best) best = result;
+}
+if (!best) {
+  throw new Error(
+    "React Router did not render a usable Cloudflare Pages static shell for any of: " +
+      candidates.join(", "),
+  );
+}
+console.log(
+  "[deploy] Static shell rendered from " + best.pathname + " (status " + best.status + ").",
+);
+fs.writeFileSync(outFile, best.html);
 process.exit(0);
 `,
   );

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

@@ -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 CHANGED Viewed

@@ -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/core/src/vite/client.ts CHANGED Viewed

@@ -1923,15 +1923,18 @@ function ssrStubPlugin(packages: string[]): Plugin | null {
     load(id) {
       if (id !== STUB_ID) return null;
       // Proxy that answers any property access with itself — lets dead
-      // import/re-export chains parse without blowing up, and still throws
-      // if code actually tries to call any of it on the server.
+      // import/re-export chains parse without blowing up. Callable and
+      // constructible (module-scope `new PluginKey(...)` in stubbed client
+      // code must not crash server-side shell renders); every call returns
+      // another stub.
       return (
         "const handler = { get(_, p) { " +
         "if (p === Symbol.toPrimitive) return () => ''; " +
         "if (p === 'then') return undefined; " +
-        "return new Proxy(() => {}, handler); " +
-        "} };" +
-        "const stub = new Proxy(() => {}, handler);" +
+        "return new Proxy(function () {}, handler); " +
+        "}, apply() { return new Proxy(function () {}, handler); }, " +
+        "construct() { return new Proxy(function () {}, handler); } };" +
+        "const stub = new Proxy(function () {}, handler);" +
         "export default stub;" +
         namedExports.map((name) => `export const ${name} = stub;`).join("")
       );

package/corpus/templates/assets/changelog/2026-07-12-image-uploads-now-work-on-serverless-runtimes-without-native.md ADDED Viewed

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-12
+---
+Image uploads now work on serverless runtimes without native image processing - dimensions are read from file headers and thumbnails fall back to the original image