@springbrand/space 0.1.0-alpha.2 → 0.1.0-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springbrand/space",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.4",
   "type": "module",
   "files": [
     "src",

package/src/space/deploy-engine.ts

@@ -1,7 +1,6 @@
 import type { Git } from "@cloudflare/shell/git"
 import type { FileSystem } from "@cloudflare/shell"
 import {
-  createApp,
   createWorker,
   inferContentType,
   isTextContentType,
@@ -29,6 +28,8 @@ export interface DeployContext {
   sql: SqlStorage
   git: Git
   fs: FileSystem
+  assetBucket?: R2Bucket
+  assetPrefix?: string
 }
 
 export interface BranchDeploymentBundle {
@@ -36,15 +37,25 @@ export interface BranchDeploymentBundle {
   commitHash: string
   mainModule: string
   modules: Record<string, string | Record<string, unknown>>
-  assets: Record<string, SerializedAsset>
+  assets: DeploymentAsset[]
   assetConfig: AssetConfig | undefined
   compatibilityDate: string
 }
 
-export type SerializedAsset = string | { base64: string }
-type WebsiteAssets = Record<string, string | ArrayBuffer>
+export interface DeploymentAsset {
+  path: string
+  contentType: string | undefined
+  etag: string
+  size: number
+}
+
+type AssetWriter = (
+  asset: Omit<DeploymentAsset, "etag">,
+  bytes: Uint8Array,
+) => Promise<string>
 
 const DEFAULT_COMPATIBILITY_DATE = "2025-04-01"
+export const MAX_STATIC_ASSET_BYTES = 25 * 1024 * 1024
 const STATIC_APP_MAIN = ".springbrand/static-app.ts"
 const STATIC_APP_SOURCE = `import { DurableObject } from "cloudflare:workers"
 
@@ -101,10 +112,12 @@ async function readBranchFiles(
   branch: string,
   appRoot = "",
   revision?: string,
+  writeAsset?: AssetWriter,
 ): Promise<{
   commitHash: string
   files: Record<string, string>
-  assets: WebsiteAssets
+  assets: DeploymentAsset[]
+  config: ParsedWranglerConfig
 }> {
   const log = await ctx.git.log({ ref: branch, depth: revision ? 1000 : 1 })
   if (log.length === 0) {
@@ -119,36 +132,81 @@ async function readBranchFiles(
 
   await ctx.git.checkout({ ref: revision ? commitHash : branch, force: true })
 
-  const files: Record<string, string> = {}
-  const assets: WebsiteAssets = {}
   try {
-    for (const fileInfo of await globInfos(ctx.fs, "**/*")) {
-      if (fileInfo.type !== "file") continue
-      // Skip git's object store and the ArtifactsFileSystem bookkeeping dir —
-      // neither is part of the app and must never ship in a deploy bundle.
-      if (fileInfo.path.startsWith("/.git/") || fileInfo.path === "/.git") continue
-      if (fileInfo.path.startsWith("/.afs/") || fileInfo.path === "/.afs") continue
-
-      let bytes: Uint8Array
-      try {
-        bytes = await ctx.fs.readFileBytes(fileInfo.path)
-      } catch {
-        continue
-      }
-      const path = fileInfo.path.startsWith("/") ? fileInfo.path.slice(1) : fileInfo.path
+    const entries: Array<{ sourcePath: string; path: string; size: number }> = []
+    for (const info of await globInfos(ctx.fs, "**/*")) {
+      if (info.type !== "file") continue
+      if (info.path.startsWith("/.git/") || info.path === "/.git") continue
+      if (info.path.startsWith("/.afs/") || info.path === "/.afs") continue
+
+      const path = info.path.startsWith("/") ? info.path.slice(1) : info.path
       if (appRoot) {
         if (path !== appRoot && !path.startsWith(`${appRoot}/`)) continue
         const relativePath = path.slice(appRoot.length + 1)
-        addWebsiteFile(files, assets, relativePath, bytes)
+        entries.push({ sourcePath: info.path, path: relativePath, size: info.size })
+        continue
+      }
+      entries.push({ sourcePath: info.path, path, size: info.size })
+    }
+
+    const configFiles: Record<string, string> = {}
+    for (const name of ["wrangler.json", "wrangler.jsonc", "wrangler.toml"]) {
+      const entry = entries.find((candidate) => candidate.path === name)
+      if (entry) configFiles[name] = await ctx.fs.readFile(entry.sourcePath)
+    }
+    let config = parseWebsiteConfig(configFiles)
+    const assetPaths = entries.map((entry) => entry.path)
+    const assetsDirectory = inferAssetsDirectory(config, configFiles, assetPaths)
+    if (!hasWrangler(configFiles) && assetsDirectory !== null) {
+      config = staticWebsiteConfig(assetsDirectory)
+    }
+
+    const files: Record<string, string> = { ...configFiles }
+    const assets: DeploymentAsset[] = []
+    for (const entry of entries) {
+      if (isAssetPath(entry.path, assetsDirectory)) {
+        if (entry.size > MAX_STATIC_ASSET_BYTES) {
+          throw new Error(
+            `Static asset "${entry.path}" is ${entry.size} bytes; the limit is ${MAX_STATIC_ASSET_BYTES} bytes`,
+          )
+        }
+        const bytes = await ctx.fs.readFileBytes(entry.sourcePath)
+        const asset: Omit<DeploymentAsset, "etag"> = {
+          path: toAssetPath(entry.path, assetsDirectory!),
+          contentType: inferContentType(entry.path),
+          size: bytes.byteLength,
+        }
+        const etag = writeAsset
+          ? await writeAsset(asset, bytes)
+          : await computeAssetEtag(bytes)
+        assets.push({ ...asset, etag })
         continue
       }
-      addWebsiteFile(files, assets, path, bytes)
+
+      const contentType = inferContentType(entry.path)
+      if (contentType !== undefined && !isTextContentType(contentType)) continue
+      if (files[entry.path] === undefined) {
+        files[entry.path] = await ctx.fs.readFile(entry.sourcePath)
+      }
     }
+
+    if (!hasWrangler(configFiles) && assetsDirectory !== null) {
+      files["wrangler.json"] = JSON.stringify({
+        main: config.main,
+        compatibility_date: config.compatibilityDate,
+        assets: {
+          directory: config.assets!.directory,
+          html_handling: config.assets!.htmlHandling,
+          not_found_handling: config.assets!.notFoundHandling,
+        },
+      })
+      files[STATIC_APP_MAIN] = STATIC_APP_SOURCE
+    }
+
+    return { commitHash, files, assets, config }
   } finally {
     if (revision) await ctx.git.checkout({ ref: branch, force: true })
   }
-
-  return { commitHash, files, assets }
 }
 
 // ─── Deploy a branch ────────────────────────────────────────────────────────
@@ -167,10 +225,43 @@ async function deployBranch(
     return jsonResponse({ error: "branch is required" }, 400)
   }
 
+  const assetDeploymentId = crypto.randomUUID()
+  const assetRoot = ctx.assetPrefix
+    ? `${ctx.assetPrefix}/deployments/${assetDeploymentId}`
+    : undefined
   let bundle: BranchDeploymentBundle
   try {
-    bundle = await buildBranchDeployment(ctx, branch, body.appRoot, body.revision)
+    bundle = await buildBranchDeployment(
+      ctx,
+      branch,
+      body.appRoot,
+      body.revision,
+      async (asset, bytes) => {
+        if (!ctx.assetBucket || !assetRoot) {
+          throw new Error("Static preview deployment requires the WORKSPACE_R2 binding")
+        }
+        const key = `${assetRoot}${asset.path}`
+        const uploaded = await ctx.assetBucket.put(key, bytes, {
+          ...(asset.contentType ? { httpMetadata: { contentType: asset.contentType } } : {}),
+        })
+        ctx.sql.exec(
+          `INSERT INTO deployment_assets
+           (deployment_id, path, r2_key, content_type, etag, size)
+           VALUES (?, ?, ?, ?, ?, ?)`,
+          assetDeploymentId,
+          asset.path,
+          key,
+          asset.contentType ?? null,
+          uploaded.etag,
+          asset.size,
+        )
+        return uploaded.etag
+      },
+    )
   } catch (e) {
+    await discardAssetDeployment(ctx, assetDeploymentId, assetRoot).catch((cleanupError) => {
+      console.warn("Failed to clean incomplete static preview deployment", cleanupError)
+    })
     const message = e instanceof Error ? e.message : String(e)
     const separator = message.indexOf(": ")
     return jsonResponse({
@@ -184,31 +275,62 @@ async function deployBranch(
     commitHash,
     mainModule,
     modules: serializedModules,
-    assets: serializedAssets,
+    assets,
     assetConfig,
     compatibilityDate: compatDate,
   } = bundle
 
   const now = Date.now()
-  ctx.sql.exec(
-    `INSERT OR REPLACE INTO deployments
-     (branch, commit_hash, main_module, modules, assets, asset_config, compatibility_date, deployed_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-    deploymentId,
-    commitHash,
-    mainModule,
-    JSON.stringify(serializedModules),
-    JSON.stringify(serializedAssets),
-    assetConfig ? JSON.stringify(assetConfig) : "{}",
-    compatDate,
-    now
-  )
+  const oldDeployment = ctx.sql
+    .exec(
+      "SELECT asset_deployment_id FROM deployments WHERE branch = ?",
+      deploymentId,
+    )
+    .toArray()[0]
+  const oldAssetDeploymentId = oldDeployment?.asset_deployment_id as string | undefined
+  try {
+    ctx.sql.exec(
+      `INSERT OR REPLACE INTO deployments
+       (branch, commit_hash, main_module, modules, assets, asset_deployment_id, asset_count,
+        asset_config, compatibility_date, deployed_at)
+       VALUES (?, ?, ?, ?, '{}', ?, ?, ?, ?, ?)`,
+      deploymentId,
+      commitHash,
+      mainModule,
+      JSON.stringify(serializedModules),
+      assets.length > 0 ? assetDeploymentId : "",
+      assets.length,
+      assetConfig ? JSON.stringify(assetConfig) : "{}",
+      compatDate,
+      now
+    )
+  } catch (error) {
+    await discardAssetDeployment(ctx, assetDeploymentId, assetRoot).catch((cleanupError) => {
+      console.warn("Failed to clean unactivated static preview deployment", cleanupError)
+    })
+    throw error
+  }
+
+  if (assets.length === 0) {
+    await discardAssetDeployment(ctx, assetDeploymentId, assetRoot).catch((error) => {
+      console.warn("Failed to clean empty static preview deployment", error)
+    })
+  }
+  if (oldAssetDeploymentId && oldAssetDeploymentId !== assetDeploymentId) {
+    await discardAssetDeployment(
+      ctx,
+      oldAssetDeploymentId,
+      ctx.assetPrefix ? `${ctx.assetPrefix}/deployments/${oldAssetDeploymentId}` : undefined,
+    ).catch((error) => {
+      console.warn("Failed to clean replaced static preview deployment", error)
+    })
+  }
 
   return jsonResponse({
     branch: deploymentId,
     commit_hash: commitHash,
     main_module: mainModule,
-    has_assets: Object.keys(serializedAssets).length > 0,
+    has_assets: assets.length > 0,
     compatibility_date: compatDate,
     deployed_at: new Date(now).toISOString(),
   })
@@ -219,9 +341,16 @@ export async function buildBranchDeployment(
   branch: string,
   appRoot?: string | null,
   revision?: string,
+  writeAsset?: AssetWriter,
 ): Promise<BranchDeploymentBundle> {
   const root = normalizeAppRoot(appRoot)
-  const { commitHash, files, assets } = await readBranchFiles(ctx, branch, root, revision)
+  const { commitHash, files, assets, config } = await readBranchFiles(
+    ctx,
+    branch,
+    root,
+    revision,
+    writeAsset,
+  )
   if (Object.keys(files).length === 0) {
     throw new Error(
       root
@@ -231,13 +360,13 @@ export async function buildBranchDeployment(
   }
 
   try {
-    const result = await buildWebsite(files, assets)
+    const result = await buildWebsite(files, config)
     return {
       branch: revision ?? branch,
       commitHash,
       mainModule: result.mainModule,
       modules: result.modules,
-      assets: serializeAssets(result.assets),
+      assets,
       assetConfig: result.assetConfig,
       compatibilityDate: result.compatibilityDate,
     }
@@ -248,20 +377,15 @@ export async function buildBranchDeployment(
 
 async function buildWebsite(
   sourceFiles: Record<string, string>,
-  sourceAssets: WebsiteAssets,
+  config: ParsedWranglerConfig,
 ) {
-  const { files, config } = prepareWebsite(sourceFiles, sourceAssets)
   if (config.durableObjects?.length) {
     throw new Error(
       "Durable Object bindings are not allowed in wrangler.json: The platform runs your app as a single Durable Object (`export class App extends DurableObject` from your main module). Do not declare `durable_objects.bindings`."
     )
   }
 
-  const assetsDirectory = normalizeAssetsDirectory(config.assets?.directory)
-  const assets = assetsDirectory === null
-    ? {}
-    : collectAssets(sourceAssets, assetsDirectory)
-  const assetConfig: AssetConfig | undefined = assetsDirectory === null
+  const assetConfig: AssetConfig | undefined = config.assets?.directory === undefined
     ? undefined
     : {
         ...(config.assets?.notFoundHandling && {
@@ -272,81 +396,48 @@ async function buildWebsite(
         }),
       }
 
-  if (Object.keys(assets).length > 0) {
-    const result = await createApp({
-      files,
-      assets,
-      assetConfig,
-      server: config.main,
-    })
-    return {
-      mainModule: result.mainModule,
-      modules: serializeModules(result.modules),
-      assets: result.assets,
-      assetConfig: result.assetConfig,
-      compatibilityDate: config.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
-    }
-  }
-
-  const result = await createWorker({ files, entryPoint: config.main })
+  const result = await createWorker({ files: sourceFiles, entryPoint: config.main })
   const modules = serializeModules(result.modules)
   modules["__STATIC_CONTENT_MANIFEST"] ??= { text: "{}" }
   return {
     mainModule: result.mainModule,
     modules,
-    assets: {},
     assetConfig,
     compatibilityDate: config.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
   }
 }
 
-function prepareWebsite(
-  files: Record<string, string>,
-  assets: WebsiteAssets,
-): { files: Record<string, string>; config: ParsedWranglerConfig } {
-  let config: ParsedWranglerConfig
+function parseWebsiteConfig(files: Record<string, string>): ParsedWranglerConfig {
   try {
-    config = parseWranglerConfig(files)
+    return parseWranglerConfig(files)
   } catch (error) {
     if (error instanceof WranglerConfigError) {
       throw new Error(`Invalid wrangler.json: ${error.message}`)
     }
     throw error
   }
-  if (hasWrangler(files) || config.main || config.assets?.directory) return { files, config }
-
-  const directory = assets["index.html"] !== undefined
-    ? "."
-    : assets["public/index.html"] !== undefined
-      ? "public"
-      : null
-  if (directory === null) return { files, config }
-
-  const generatedAssets = {
-    directory,
-    htmlHandling: "auto-trailing-slash" as const,
-    notFoundHandling: "404-page" as const,
-  }
-  config = {
+}
+
+function inferAssetsDirectory(
+  config: ParsedWranglerConfig,
+  configFiles: Record<string, string>,
+  paths: string[],
+): string | null {
+  if (hasWrangler(configFiles)) return normalizeAssetsDirectory(config.assets?.directory)
+  if (paths.includes("index.html")) return ""
+  if (paths.includes("public/index.html")) return "public"
+  return null
+}
+
+function staticWebsiteConfig(directory: string): ParsedWranglerConfig {
+  return {
     main: STATIC_APP_MAIN,
     compatibilityDate: DEFAULT_COMPATIBILITY_DATE,
-    assets: generatedAssets,
-  }
-  return {
-    files: {
-      ...files,
-      "wrangler.json": JSON.stringify({
-        main: config.main,
-        compatibility_date: config.compatibilityDate,
-        assets: {
-          directory: generatedAssets.directory,
-          html_handling: generatedAssets.htmlHandling,
-          not_found_handling: generatedAssets.notFoundHandling,
-        },
-      }),
-      [STATIC_APP_MAIN]: STATIC_APP_SOURCE,
+    assets: {
+      directory: directory || ".",
+      htmlHandling: "auto-trailing-slash",
+      notFoundHandling: "404-page",
     },
-    config,
   }
 }
 
@@ -361,15 +452,20 @@ function normalizeAssetsDirectory(directory?: string): string | null {
   return normalized === "." ? "" : normalized
 }
 
-function collectAssets(assets: WebsiteAssets, directory: string): WebsiteAssets {
-  return Object.fromEntries(
-    Object.entries(assets)
-      .filter(([path]) => !directory || path === directory || path.startsWith(`${directory}/`))
-      .map(([path, content]) => [
-        directory ? `/${path.slice(directory.length + 1)}` : `/${path}`,
-        content,
-      ]),
-  )
+function isAssetPath(path: string, directory: string | null): boolean {
+  if (directory === null) return false
+  return directory === "" || path.startsWith(`${directory}/`)
+}
+
+function toAssetPath(path: string, directory: string): string {
+  return directory ? `/${path.slice(directory.length + 1)}` : `/${path}`
+}
+
+async function computeAssetEtag(bytes: Uint8Array): Promise<string> {
+  const digest = await crypto.subtle.digest("SHA-256", exactBuffer(bytes))
+  return [...new Uint8Array(digest).slice(0, 8)]
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("")
 }
 
 function serializeModules(modules: Modules): Record<string, string | Record<string, unknown>> {
@@ -394,7 +490,9 @@ async function getDeployment(
 
   const row = ctx.sql
     .exec(
-      "SELECT branch, commit_hash, main_module, modules, assets, asset_config, deployed_at FROM deployments WHERE branch = ?",
+      `SELECT branch, commit_hash, main_module, modules, assets, asset_count,
+              asset_config, deployed_at
+       FROM deployments WHERE branch = ?`,
       branch
     )
     .toArray()
@@ -404,13 +502,13 @@ async function getDeployment(
   }
 
   const r = row[0]
-  const assets = JSON.parse((r.assets as string) || "{}")
+  const legacyAssets = JSON.parse((r.assets as string) || "{}")
   return jsonResponse({
     branch: r.branch as string,
     commit_hash: r.commit_hash as string,
     main_module: r.main_module as string,
     modules: JSON.parse(r.modules as string),
-    has_assets: Object.keys(assets).length > 0,
+    has_assets: Number(r.asset_count ?? 0) > 0 || Object.keys(legacyAssets).length > 0,
     deployed_at: new Date(r.deployed_at as number).toISOString(),
   })
 }
@@ -419,16 +517,19 @@ async function getDeployment(
 
 async function listDeployments(ctx: DeployContext): Promise<Response> {
   const rows = ctx.sql
-    .exec("SELECT branch, commit_hash, main_module, assets, deployed_at FROM deployments ORDER BY deployed_at DESC")
+    .exec(
+      `SELECT branch, commit_hash, main_module, assets, asset_count, deployed_at
+       FROM deployments ORDER BY deployed_at DESC`,
+    )
     .toArray()
 
   const deployments = rows.map((r) => {
-    const assets = JSON.parse((r.assets as string) || "{}")
+    const legacyAssets = JSON.parse((r.assets as string) || "{}")
     return {
       branch: r.branch as string,
       commit_hash: r.commit_hash as string,
       main_module: r.main_module as string,
-      has_assets: Object.keys(assets).length > 0,
+      has_assets: Number(r.asset_count ?? 0) > 0 || Object.keys(legacyAssets).length > 0,
       deployed_at: new Date(r.deployed_at as number).toISOString(),
     }
   })
@@ -448,6 +549,9 @@ async function undeployBranch(
     return jsonResponse({ error: "branch is required" }, 400)
   }
 
+  const row = ctx.sql
+    .exec("SELECT asset_deployment_id FROM deployments WHERE branch = ?", branch)
+    .toArray()[0]
   const result = ctx.sql.exec(
     "DELETE FROM deployments WHERE branch = ?",
     branch
@@ -457,48 +561,44 @@ async function undeployBranch(
     return jsonResponse({ error: `No deployment found for branch "${branch}"` }, 404)
   }
 
-  return jsonResponse({ ok: true, branch })
-}
-
-// ─── Serialization helpers ───────────────────────────────────────────────────
-
-function serializeAssets(
-  assets: Record<string, string | ArrayBuffer>
-): Record<string, SerializedAsset> {
-  const out: Record<string, SerializedAsset> = {}
-  for (const [path, content] of Object.entries(assets)) {
-    out[path] = typeof content === "string"
-      ? content
-      : { base64: bytesToBase64(new Uint8Array(content)) }
+  const assetDeploymentId = row?.asset_deployment_id as string | undefined
+  if (assetDeploymentId) {
+    await discardAssetDeployment(
+      ctx,
+      assetDeploymentId,
+      ctx.assetPrefix ? `${ctx.assetPrefix}/deployments/${assetDeploymentId}` : undefined,
+    ).catch((error) => {
+      console.warn("Failed to clean undeployed static preview assets", error)
+    })
   }
-  return out
+
+  return jsonResponse({ ok: true, branch })
 }
 
-function addWebsiteFile(
-  files: Record<string, string>,
-  assets: WebsiteAssets,
-  path: string,
-  bytes: Uint8Array,
-): void {
-  const contentType = inferContentType(path)
-  const binary = contentType !== undefined && !isTextContentType(contentType)
-  if (binary) {
-    assets[path] = exactBuffer(bytes)
-    return
+async function discardAssetDeployment(
+  ctx: DeployContext,
+  deploymentId: string,
+  root: string | undefined,
+): Promise<void> {
+  try {
+    if (ctx.assetBucket && root) {
+      let cursor: string | undefined
+      do {
+        const page = await ctx.assetBucket.list({
+          prefix: `${root}/`,
+          limit: 1000,
+          ...(cursor ? { cursor } : {}),
+        })
+        const keys = page.objects.map((object) => object.key)
+        if (keys.length > 0) await ctx.assetBucket.delete(keys)
+        cursor = page.truncated ? page.cursor : undefined
+      } while (cursor)
+    }
+  } finally {
+    ctx.sql.exec("DELETE FROM deployment_assets WHERE deployment_id = ?", deploymentId)
   }
-  const text = new TextDecoder().decode(bytes)
-  files[path] = text
-  assets[path] = text
 }
 
 function exactBuffer(bytes: Uint8Array): ArrayBuffer {
   return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
 }
-
-function bytesToBase64(bytes: Uint8Array): string {
-  let binary = ""
-  for (let offset = 0; offset < bytes.length; offset += 0x8000) {
-    binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000))
-  }
-  return btoa(binary)
-}

package/src/space/durable-object.ts

@@ -7,10 +7,16 @@ import {
   handleDeployCommand,
   type BranchDeploymentBundle,
   type DeployContext,
-  type SerializedAsset,
 } from "./deploy-engine"
 import { globInfos, readDirInfos, toFileInfo } from "./fileinfo"
-import { handleAssetRequest, buildAssetManifest, createMemoryStorage, type AssetConfig } from "@cloudflare/worker-bundler"
+import {
+  handleAssetRequest,
+  buildAssetManifest,
+  createMemoryStorage,
+  type AssetConfig,
+  type AssetManifest,
+  type AssetStorage,
+} from "@cloudflare/worker-bundler"
 import {
   buildInspectorWrapperSource,
   VIBE_APP_MODULE,
@@ -94,11 +100,15 @@ interface DeploymentRow {
   commitHash: string
   mainModule: string
   modules: Record<string, string | Record<string, unknown>>
-  assets: Record<string, string | ArrayBuffer>
+  legacyAssets: Record<string, string | ArrayBuffer>
+  assetDeploymentId: string
+  assetCount: number
   assetConfig: AssetConfig
   compatibilityDate: string
 }
 
+type SerializedAsset = string | { base64: string }
+
 function deserializeAssets(
   assets: Record<string, SerializedAsset>,
 ): Record<string, string | ArrayBuffer> {
@@ -141,8 +151,8 @@ const isReservedPath = isReservedSpacePath
 // these on every request is wasteful (CWE-770 amplification under a preview
 // flood), so we cache them per `branch:commitHash` with an LRU + TTL bound.
 type CachedAssets = {
-  manifest: Awaited<ReturnType<typeof buildAssetManifest>>
-  storage: ReturnType<typeof createMemoryStorage>
+  manifest: AssetManifest
+  storage: AssetStorage
   expiresAt: number
 }
 const ASSET_CACHE_MAX_ENTRIES = 8
@@ -209,14 +219,27 @@ export class SpaceDO extends DurableObject<Env>
         main_module TEXT NOT NULL,
         modules TEXT NOT NULL,
         assets TEXT NOT NULL DEFAULT '{}',
+        asset_deployment_id TEXT NOT NULL DEFAULT '',
+        asset_count INTEGER NOT NULL DEFAULT 0,
         asset_config TEXT NOT NULL DEFAULT '{}',
         compatibility_date TEXT NOT NULL DEFAULT '',
         deployed_at INTEGER NOT NULL
-      )
+      );
+      CREATE TABLE IF NOT EXISTS deployment_assets (
+        deployment_id TEXT NOT NULL,
+        path TEXT NOT NULL,
+        r2_key TEXT NOT NULL,
+        content_type TEXT,
+        etag TEXT NOT NULL,
+        size INTEGER NOT NULL,
+        PRIMARY KEY (deployment_id, path)
+      );
     `)
 
     // Migrate existing deployments tables that lack new columns
     try { this.ctx.storage.sql.exec(`ALTER TABLE deployments ADD COLUMN assets TEXT NOT NULL DEFAULT '{}'`) } catch {}
+    try { this.ctx.storage.sql.exec(`ALTER TABLE deployments ADD COLUMN asset_deployment_id TEXT NOT NULL DEFAULT ''`) } catch {}
+    try { this.ctx.storage.sql.exec(`ALTER TABLE deployments ADD COLUMN asset_count INTEGER NOT NULL DEFAULT 0`) } catch {}
     try { this.ctx.storage.sql.exec(`ALTER TABLE deployments ADD COLUMN asset_config TEXT NOT NULL DEFAULT '{}'`) } catch {}
     try { this.ctx.storage.sql.exec(`ALTER TABLE deployments ADD COLUMN compatibility_date TEXT NOT NULL DEFAULT ''`) } catch {}
 
@@ -634,7 +657,7 @@ export class SpaceDO extends DurableObject<Env>
     const prefix = `${spaceR2Prefix(this.spaceName)}/`
     let cursor: string | undefined
     do {
-      const page = await bucket.list({ prefix, ...(cursor ? { cursor } : {}) })
+      const page = await bucket.list({ prefix, limit: 1000, ...(cursor ? { cursor } : {}) })
       const keys = page.objects.map((object) => object.key)
       if (keys.length > 0) await bucket.delete(keys)
       cursor = page.truncated ? page.cursor : undefined
@@ -1106,10 +1129,13 @@ export class SpaceDO extends DurableObject<Env>
         sql: this.ctx.storage.sql,
         git: this.git,
         fs: this.fs,
+        assetBucket: this.env.WORKSPACE_R2,
+        assetPrefix: spaceR2Prefix(this.spaceName),
       }
       const res = await handleDeployCommand(ctx, "deploy", fakeRequest)
       const data = await res.json() as Record<string, unknown>
       if (typeof data.error === "string") throw new Error(data.error)
+      this.assetCache.clear()
       const deploymentId = data.branch as string
       data.preview_url =
         `/space/${this.spaceName}/preview/${encodeURIComponent(deploymentId)}/`
@@ -1150,8 +1176,11 @@ export class SpaceDO extends DurableObject<Env>
       sql: this.ctx.storage.sql,
       git: this.git,
       fs: this.overlay,
+      assetBucket: this.env.WORKSPACE_R2,
+      assetPrefix: spaceR2Prefix(this.spaceName),
     }
     const res = await handleDeployCommand(ctx, "undeploy", fakeRequest)
+    this.assetCache.clear()
     return res.json()
   }
 
@@ -1204,7 +1233,9 @@ export class SpaceDO extends DurableObject<Env>
   private readDeployment(branch: string): DeploymentRow | null {
     const rows = this.ctx.storage.sql
       .exec(
-        "SELECT branch, commit_hash, main_module, modules, assets, asset_config, compatibility_date FROM deployments WHERE branch = ?",
+        `SELECT branch, commit_hash, main_module, modules, assets,
+                asset_deployment_id, asset_count, asset_config, compatibility_date
+         FROM deployments WHERE branch = ?`,
         branch,
       )
       .toArray()
@@ -1215,9 +1246,11 @@ export class SpaceDO extends DurableObject<Env>
       commitHash: r.commit_hash as string,
       mainModule: r.main_module as string,
       modules: JSON.parse(r.modules as string) as Record<string, string | Record<string, unknown>>,
-      assets: deserializeAssets(
+      legacyAssets: deserializeAssets(
         JSON.parse((r.assets as string) || "{}") as Record<string, SerializedAsset>,
       ),
+      assetDeploymentId: (r.asset_deployment_id as string) || "",
+      assetCount: Number(r.asset_count ?? 0),
       assetConfig: JSON.parse((r.asset_config as string) || "{}") as AssetConfig,
       compatibilityDate: (r.compatibility_date as string) || FALLBACK_COMPATIBILITY_DATE,
     }
@@ -1255,7 +1288,7 @@ export class SpaceDO extends DurableObject<Env>
     // Serve static assets host-side before forwarding to the Facet. The built
     // manifest/storage are cached per deployment so repeat asset reads don't
     // re-spin the build on every request.
-    if (Object.keys(dep.assets).length > 0) {
+    if (dep.assetCount > 0 || Object.keys(dep.legacyAssets).length > 0) {
       const { manifest, storage } = await this.getCachedAssets(dep)
       const assetResponse = await handleAssetRequest(request, manifest, storage, dep.assetConfig)
       if (assetResponse) return assetResponse
@@ -1281,7 +1314,7 @@ export class SpaceDO extends DurableObject<Env>
    * redeploy (new commit) transparently rebuilds. Bounded by an LRU cap + TTL.
    */
   private async getCachedAssets(dep: DeploymentRow): Promise<CachedAssets> {
-    const key = `${dep.branch}:${dep.commitHash}`
+    const key = `${dep.branch}:${dep.assetDeploymentId || dep.commitHash}`
     const now = Date.now()
 
     const cached = this.assetCache.get(key)
@@ -1292,8 +1325,39 @@ export class SpaceDO extends DurableObject<Env>
       return cached
     }
 
-    const manifest = await buildAssetManifest(dep.assets)
-    const storage = createMemoryStorage(dep.assets)
+    let manifest: AssetManifest
+    let storage: AssetStorage
+    if (dep.assetDeploymentId) {
+      const bucket = this.env.WORKSPACE_R2
+      if (!bucket) throw new Error("Static preview requires the WORKSPACE_R2 binding")
+      const rows = this.ctx.storage.sql
+        .exec(
+          `SELECT path, r2_key, content_type, etag
+           FROM deployment_assets WHERE deployment_id = ?`,
+          dep.assetDeploymentId,
+        )
+        .toArray()
+      const keys = new Map<string, string>()
+      manifest = new Map()
+      for (const row of rows) {
+        const path = row.path as string
+        keys.set(path, row.r2_key as string)
+        manifest.set(path, {
+          contentType: (row.content_type as string | null) ?? undefined,
+          etag: row.etag as string,
+        })
+      }
+      storage = {
+        async get(pathname) {
+          const r2Key = keys.get(pathname)
+          if (!r2Key) return null
+          return (await bucket.get(r2Key))?.body ?? null
+        },
+      }
+    } else {
+      manifest = await buildAssetManifest(dep.legacyAssets)
+      storage = createMemoryStorage(dep.legacyAssets)
+    }
     const entry: CachedAssets = { manifest, storage, expiresAt: now + ASSET_CACHE_TTL_MS }
 
     this.assetCache.set(key, entry)
@@ -1449,6 +1513,8 @@ export class SpaceDO extends DurableObject<Env>
         sql: this.ctx.storage.sql,
         git: this.git,
         fs: this.overlay,
+        assetBucket: this.env.WORKSPACE_R2,
+        assetPrefix: spaceR2Prefix(this.spaceName),
       }
       return handleDeployCommand(deployCtx, cmd, request)
     }