@springbrand/space 0.2.0-alpha.0 → 0.2.0-alpha.10

package/README.md

@@ -25,5 +25,4 @@ whether the caller may reach it.
 Preview publication writes static assets below one immutable R2 deployment
 prefix and returns that prefix to the host. Static requests can therefore go
 straight to a Workspace CDN; `serveApp()` is the dynamic-only path into the App
-Facet. `servePreview()` remains available for hosts that intentionally proxy
-both asset and backend traffic through SpaceDO.
+Facet. SpaceDO never reads static assets for browser requests.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springbrand/space",
-  "version": "0.2.0-alpha.0",
+  "version": "0.2.0-alpha.10",
   "type": "module",
   "files": [
     "src",

package/src/index.ts

@@ -9,6 +9,7 @@ export type {
   AppTableQueryOpts,
   SpaceCommit,
   SpaceConditionalWriteResult,
+  SpaceStreamWriteOptions,
   SpaceAppPort,
   SpaceControlPort,
   SpaceFileInfo,

package/src/space/deploy-engine.ts

@@ -304,7 +304,6 @@ async function deployBranch(
       compatibilityDate: compatDate,
     },
     staticAssets: assets,
-    assetConfig,
   } = bundle
 
   const now = Date.now()
@@ -318,16 +317,14 @@ async function deployBranch(
   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 (?, ?, ?, ?, '{}', ?, ?, ?, ?, ?)`,
+       (branch, commit_hash, main_module, modules, asset_deployment_id,
+        compatibility_date, deployed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
       deploymentId,
       commitHash,
       mainModule,
       JSON.stringify(serializedModules),
       assets.length > 0 ? assetDeploymentId : "",
-      assets.length,
-      assetConfig ? JSON.stringify(assetConfig) : "{}",
       compatDate,
       now
     )
@@ -558,8 +555,7 @@ async function getDeployment(
 
   const row = ctx.sql
     .exec(
-      `SELECT branch, commit_hash, main_module, modules, assets, asset_deployment_id, asset_count,
-              asset_config, deployed_at
+      `SELECT branch, commit_hash, main_module, modules, asset_deployment_id, deployed_at
        FROM deployments WHERE branch = ?`,
       branch
     )
@@ -570,14 +566,13 @@ async function getDeployment(
   }
 
   const r = row[0]
-  const legacyAssets = JSON.parse((r.assets as string) || "{}")
   const assetDeploymentId = (r.asset_deployment_id 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: Number(r.asset_count ?? 0) > 0 || Object.keys(legacyAssets).length > 0,
+    has_assets: Boolean(assetDeploymentId),
     deployed_at: new Date(r.deployed_at as number).toISOString(),
     asset_root: assetDeploymentId && ctx.assetPrefix
       ? `${ctx.assetPrefix}/deployments/${assetDeploymentId}`
@@ -590,21 +585,17 @@ async function getDeployment(
 async function listDeployments(ctx: DeployContext): Promise<Response> {
   const rows = ctx.sql
     .exec(
-      `SELECT branch, commit_hash, main_module, assets, asset_count, deployed_at
+      `SELECT branch, commit_hash, main_module, asset_deployment_id, deployed_at
        FROM deployments ORDER BY deployed_at DESC`,
     )
     .toArray()
-
-  const deployments = rows.map((r) => {
-    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: Number(r.asset_count ?? 0) > 0 || Object.keys(legacyAssets).length > 0,
-      deployed_at: new Date(r.deployed_at as number).toISOString(),
-    }
-  })
+  const deployments = rows.map((r) => ({
+    branch: r.branch as string,
+    commit_hash: r.commit_hash as string,
+    main_module: r.main_module as string,
+    has_assets: Boolean(r.asset_deployment_id),
+    deployed_at: new Date(r.deployed_at as number).toISOString(),
+  }))
 
   return jsonResponse(deployments)
 }

package/src/space/durable-object.ts

@@ -11,21 +11,12 @@ import {
   type SpaceDeploymentResult,
 } from "./deploy-engine"
 import { globInfos, readDirInfos, toFileInfo } from "./fileinfo"
-import {
-  handleAssetRequest,
-  buildAssetManifest,
-  createMemoryStorage,
-  type AssetConfig,
-  type AssetManifest,
-  type AssetStorage,
-} from "@cloudflare/worker-bundler"
 import {
   buildInspectorWrapperSource,
   VIBE_APP_MODULE,
 } from "./inspector-wrapper"
 import { ArtifactsBackend, resolveSpaceFsBackendMode, SqlBackend, spaceR2Prefix, type SpaceFsBackend } from "./fs-backend"
 import { createGitFs, stageWorkdir } from "./git-objects"
-import { stripPreviewSecurityHeaders } from "./preview-headers"
 import * as git from "isomorphic-git"
 import {
   defaultSpaceQuota,
@@ -39,6 +30,7 @@ import {
   type SpaceCommit,
   type SpaceCommitManifest,
   type SpaceConditionalWriteResult,
+  type SpaceStreamWriteOptions,
   type SpaceAppPort,
   type SpaceControlPort,
   type SpaceFileInfo,
@@ -57,6 +49,7 @@ export type {
   SpaceCommit,
   SpaceCommitManifest,
   SpaceConditionalWriteResult,
+  SpaceStreamWriteOptions,
   SpaceControlPort,
   SpaceFileInfo,
   SpaceFileVersion,
@@ -102,41 +95,9 @@ interface DeploymentRow {
   commitHash: string
   mainModule: string
   modules: Record<string, string | Record<string, unknown>>
-  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> {
-  return Object.fromEntries(
-    Object.entries(assets).map(([path, content]) => [
-      path,
-      typeof content === "string"
-        ? content
-        : exactArrayBuffer(base64ToBytes(content.base64)),
-    ]),
-  )
-}
-
-function exactArrayBuffer(bytes: Uint8Array): ArrayBuffer {
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
-}
-
-function base64ToBytes(value: string): Uint8Array {
-  const binary = atob(value)
-  const bytes = new Uint8Array(binary.length)
-  for (let index = 0; index < binary.length; index++) {
-    bytes[index] = binary.charCodeAt(index)
-  }
-  return bytes
-}
-
 // Overlay-only paths that must never leak into a deploy, rollback tree, or any
 // file listing: git's object store and the ArtifactsFileSystem bookkeeping dir.
 const isReservedPath = isReservedSpacePath
@@ -149,22 +110,10 @@ const isReservedPath = isReservedSpacePath
 // Commits/deploys are mirrored to a per-app Cloudflare Artifacts repo
 // (see artifacts-sync.ts), which is the durable source of truth for history.
 
-// Built asset manifest + in-memory storage for a single deployment. Rebuilding
-// 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: AssetManifest
-  storage: AssetStorage
-  expiresAt: number
-}
-const ASSET_CACHE_MAX_ENTRIES = 8
-const ASSET_CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
-
 export class SpaceDO extends DurableObject<Env>
   implements SpaceWorkspacePort, SpaceControlPort, SpaceAppPort {
   private backend!: SpaceFsBackend
   private initializationPromise: Promise<void> | null = null
-  private assetCache = new Map<string, CachedAssets>()
   /**
    * One lane for every operation that reads or rewrites the whole tree.
    *
@@ -220,11 +169,8 @@ export class SpaceDO extends DurableObject<Env>
         commit_hash TEXT NOT NULL,
         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 '',
+        compatibility_date TEXT NOT NULL,
         deployed_at INTEGER NOT NULL
       );
       CREATE TABLE IF NOT EXISTS deployment_assets (
@@ -238,13 +184,6 @@ export class SpaceDO extends DurableObject<Env>
       );
     `)
 
-    // 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 {}
-
     // Initialize git repo if not already done
     try {
       await this.git.init({ defaultBranch: "main" })
@@ -320,6 +259,21 @@ export class SpaceDO extends DurableObject<Env>
     }
   }
 
+  private async streamedFileLimit(path: string): Promise<number> {
+    const quota = defaultSpaceQuota()
+    const existing = await this.statInfo(path)
+    const usage = await this.usageOf()
+    if (quota.maxFiles !== null && !existing && usage.fileCount >= quota.maxFiles) {
+      throw new Error("Space file count quota exceeded")
+    }
+    return Math.max(0, Math.min(
+      quota.maxFileBytes ?? Number.MAX_SAFE_INTEGER,
+      quota.maxTotalBytes === null
+        ? Number.MAX_SAFE_INTEGER
+        : quota.maxTotalBytes - usage.totalBytes + (existing?.size ?? 0),
+    ))
+  }
+
   private async usageOf(): Promise<SpaceUsage> {
     let fileCount = 0
     let directoryCount = 0
@@ -636,7 +590,6 @@ export class SpaceDO extends DurableObject<Env>
         }
       }
       await this.deleteSpilledObjects()
-      this.assetCache.clear()
       await this.ctx.storage.deleteAll()
       this.initializationPromise = null
     })
@@ -727,6 +680,44 @@ export class SpaceDO extends DurableObject<Env>
     await this.fs.writeFileBytes(target, bytes)
   }
 
+  async writeFileStream(
+    path: string,
+    content: ReadableStream<Uint8Array>,
+    options?: SpaceStreamWriteOptions,
+  ): Promise<{ path: string; bytes: number }> {
+    return this.lane(async () => {
+      await this.ensureInit()
+      const target = normalizeWritableSpacePath(path)
+      const expected = options?.contentLength
+      if (expected !== undefined && (!Number.isSafeInteger(expected) || expected < 0)) {
+        throw new Error("Stream contentLength must be a non-negative safe integer")
+      }
+      const limit = await this.streamedFileLimit(target)
+      if (expected !== undefined && expected > limit) {
+        throw new Error(`Space file exceeds the ${limit}-byte limit: ${target}`)
+      }
+      let bytes = 0
+      const counted = content.pipeThrough(new TransformStream<Uint8Array, Uint8Array>({
+        transform(chunk, controller) {
+          bytes += chunk.byteLength
+          if (bytes > limit) throw new Error(`Space file exceeds the ${limit}-byte limit: ${target}`)
+          controller.enqueue(chunk)
+        },
+        flush() {
+          if (expected !== undefined && bytes !== expected) {
+            throw new Error("Stream did not match declared contentLength")
+          }
+        },
+      }))
+      await this.backend.writeFileStream(
+        target,
+        counted,
+        options?.mediaType ?? "application/octet-stream",
+      )
+      return { path: target, bytes }
+    })
+  }
+
   async appendFile(path: string, content: string, mimeType?: string): Promise<void> {
     void mimeType
     await this.ensureInit()
@@ -1143,10 +1134,6 @@ export class SpaceDO extends DurableObject<Env>
       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)}/`
 
       if (!revision) await this.backend.push(branch)
 
@@ -1191,7 +1178,6 @@ export class SpaceDO extends DurableObject<Env>
       assetPrefix: spaceR2Prefix(this.spaceName),
     }
     const res = await handleDeployCommand(ctx, "undeploy", fakeRequest)
-    this.assetCache.clear()
     return res.json()
   }
 
@@ -1240,13 +1226,12 @@ export class SpaceDO extends DurableObject<Env>
     return { fileCount, directoryCount, totalBytes }
   }
 
-  // ── Deployment row reader (shared by servePreview + DB-viewer) ──
+  // ── Deployment row reader ──
 
   private readDeployment(branch: string): DeploymentRow | null {
     const rows = this.ctx.storage.sql
       .exec(
-        `SELECT branch, commit_hash, main_module, modules, assets,
-                asset_deployment_id, asset_count, asset_config, compatibility_date
+        `SELECT branch, commit_hash, main_module, modules, compatibility_date
          FROM deployments WHERE branch = ?`,
         branch,
       )
@@ -1258,17 +1243,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>>,
-      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,
+      compatibilityDate: r.compatibility_date as string,
     }
   }
 
-  // ── Preview serving via Dynamic Workers ─────────────────────────
+  // ── App serving via Dynamic Workers ─────────────────────────────
   //
   // Architecture (matches Cloudflare's Durable Object Facets docs example):
   //
@@ -1276,10 +1255,8 @@ export class SpaceDO extends DurableObject<Env>
   //     module. `App.fetch(request)` is the entire backend (Hono /
   //     itty-router / vanilla — the LLM decides).
   //   - SpaceDO acts as the supervisor ("AppRunner" in the docs).
-  //     `servePreview` loads the user's worker via the Worker Loader,
-  //     extracts the App class, and hosts it as a Facet keyed
-  //     `app:<branch>`. Static assets are served host-side; everything
-  //     else (including WebSocket upgrades) is forwarded into the Facet.
+  //     `serveApp` loads the user's worker via the Worker Loader, extracts the
+  //     App class, and hosts it as a Facet keyed `app:<branch>`.
   //   - State is the Facet's own `ctx.storage` (SQLite + KV). No env.DB
   //     binding is injected.
   //   - To make the DB-viewer work without forcing the LLM to write
@@ -1289,40 +1266,12 @@ export class SpaceDO extends DurableObject<Env>
   //     `App` that adds `__vibeInspectListTables` / `__vibeInspectRead`
   //     / `__vibeWipe`. The subclass shares the same `ctx.storage`.
 
-  async servePreview(branch: string, request: Request): Promise<Response> {
-    await this.ensureInit()
-
-    const dep = this.readDeployment(branch)
-    if (!dep) {
-      return new Response(`No deployment found for branch "${branch}"`, { status: 404 })
-    }
-
-    // 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 (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
-    }
-
-    return this.serveDeploymentApp(branch, dep, request)
-  }
-
   async serveApp(branch: string, request: Request): Promise<Response> {
     await this.ensureInit()
     const dep = this.readDeployment(branch)
     if (!dep) {
       return new Response(`No deployment found for branch "${branch}"`, { status: 404 })
     }
-    return this.serveDeploymentApp(branch, dep, request)
-  }
-
-  private serveDeploymentApp(
-    branch: string,
-    dep: DeploymentRow,
-    request: Request,
-  ): Response | Promise<Response> {
     let appClass: DurableObjectClass
     try {
       appClass = this.loadAppClass(dep)
@@ -1337,73 +1286,6 @@ export class SpaceDO extends DurableObject<Env>
     return facet.fetch(request)
   }
 
-  /**
-   * Return the built asset manifest + in-memory storage for a deployment,
-   * reusing a cached build when available. Keyed by `branch:commitHash` so a
-   * redeploy (new commit) transparently rebuilds. Bounded by an LRU cap + TTL.
-   */
-  private async getCachedAssets(dep: DeploymentRow): Promise<CachedAssets> {
-    const key = `${dep.branch}:${dep.assetDeploymentId || dep.commitHash}`
-    const now = Date.now()
-
-    const cached = this.assetCache.get(key)
-    if (cached && cached.expiresAt > now) {
-      // Refresh LRU recency.
-      this.assetCache.delete(key)
-      this.assetCache.set(key, cached)
-      return cached
-    }
-
-    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)
-
-    // Evict expired / oldest entries to keep the cache bounded.
-    for (const [k, v] of this.assetCache) {
-      if (v.expiresAt <= now) this.assetCache.delete(k)
-    }
-    while (this.assetCache.size > ASSET_CACHE_MAX_ENTRIES) {
-      const oldest = this.assetCache.keys().next().value
-      if (oldest === undefined) break
-      this.assetCache.delete(oldest)
-    }
-
-    return entry
-  }
-
   // ── App-class loader ────────────────────────────────────────────
   //
   // Loads the dynamic worker for `branch`'s latest deployment with the
@@ -1428,7 +1310,7 @@ export class SpaceDO extends DurableObject<Env>
       // The date the app declared, not a date frozen into this file. A worker
       // built against one runtime and run under another is a bug the author
       // cannot see or fix.
-      compatibilityDate: dep.compatibilityDate || FALLBACK_COMPATIBILITY_DATE,
+      compatibilityDate: dep.compatibilityDate,
       // Generated code gets no outbound network. Omitting this inherits the
       // parent Worker's full internet access, which would let an app the model
       // wrote reach anything this Worker can — including internal services.
@@ -1503,40 +1385,12 @@ export class SpaceDO extends DurableObject<Env>
     return { ok: true }
   }
 
-  // ── HTTP handler: preview serving + internal deploy commands ────
+  // ── Internal deploy commands ──
 
   async fetch(request: Request): Promise<Response> {
     await this.ensureInit()
 
-    const url = new URL(request.url)
-    const path = url.pathname
-
-    // Preview routes: /space/:name/preview/:branch/*
-    const previewMatch = path.match(/\/preview\/([^/]+)(\/.*)?$/)
-    if (previewMatch) {
-      const branch = decodeURIComponent(previewMatch[1])
-      const spaceName = this.ctx.id.name ?? "space"
-      const basePath = `/space/${spaceName}/preview/${encodeURIComponent(branch)}`
-
-      // Rewrite the URL so the dynamic worker sees a clean path
-      const subPath = previewMatch[2] || "/"
-      const previewUrl = new URL(subPath, url.origin)
-      previewUrl.search = url.search
-      const previewRequest = new Request(previewUrl.toString(), request)
-      const response = await this.servePreview(branch, previewRequest)
-
-      // Strip headers a generated app must not be able to set on the shared
-      // preview origin (e.g. Service-Worker-Allowed scope expansion) before
-      // any further rewriting.
-      const safeResponse = stripPreviewSecurityHeaders(response)
-
-      // Rewrite root-relative paths in HTML responses so they resolve
-      // correctly when the preview is mounted on a sub-path
-      return rewritePreviewResponse(safeResponse, basePath)
-    }
-
-    // Deploy command routes
-    const cmd = url.searchParams.get("cmd")
+    const cmd = new URL(request.url).searchParams.get("cmd")
     if (cmd && ["deploy", "get_deployment", "list_deployments", "undeploy"].includes(cmd)) {
       const deployCtx: DeployContext = {
         sql: this.ctx.storage.sql,
@@ -1552,39 +1406,6 @@ export class SpaceDO extends DurableObject<Env>
   }
 }
 
-// ─── Preview Response Rewriting ──────────────────────────────────────────────
-// When a preview is served on /space/:name/preview/:branch/, root-relative
-// paths like /style.css in HTML would resolve to the domain root instead of
-// the preview path. We rewrite them so the browser fetches the correct URL.
-
-function rewritePreviewResponse(response: Response, basePath: string): Response {
-  // Rewrite Location header on redirects
-  const location = response.headers.get("location")
-  if (location?.startsWith("/")) {
-    const rewritten = new Response(response.body, response)
-    rewritten.headers.set("location", basePath + location)
-    return rewritten
-  }
-
-  // Only rewrite HTML responses
-  const ct = response.headers.get("content-type") ?? ""
-  if (!ct.includes("text/html")) return response
-
-  // Use HTMLRewriter to prefix root-relative src/href/action attributes
-  return new HTMLRewriter()
-    .on("[src],[href],[action]", {
-      element(el) {
-        for (const attr of ["src", "href", "action"] as const) {
-          const val = el.getAttribute(attr)
-          if (val?.startsWith("/") && !val.startsWith("//")) {
-            el.setAttribute(attr, basePath + val)
-          }
-        }
-      },
-    })
-    .transform(response)
-}
-
 // ─── Facet naming ───────────────────────────────────────────────────────────
 
 function facetNameForApp(branch: string): string {
@@ -1596,9 +1417,6 @@ function facetNameForApp(branch: string): string {
 /** Git's oid for an empty tree — what a repository with no content writes. */
 const EMPTY_TREE_OID = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
 
-/** Used only for deployments recorded before the date was persisted. */
-const FALLBACK_COMPATIBILITY_DATE = "2025-04-01"
-
 const SPACE_AUTHOR = Object.freeze({
   name: "Workspace",
   email: "workspace@springbrand.local",

package/src/space/fs-backend.ts

@@ -47,6 +47,7 @@ export interface SpaceFsBackend {
   ready(): Promise<void>
   hydrate(path: string): Promise<void>
   materializeAll(): Promise<void>
+  writeFileStream(path: string, content: ReadableStream<Uint8Array>, mediaType: string): Promise<void>
   flushCheckpoint(): Promise<void>
   push(branch: string): Promise<boolean>
   fetch(branch: string): Promise<void>
@@ -134,6 +135,10 @@ export class ArtifactsBackend implements SpaceFsBackend {
     await (this.fs as ArtifactsFileSystem).whenFullyMaterialized()
   }
 
+  async writeFileStream(): Promise<void> {
+    throw new Error("Streaming writes require the SQL Space backend")
+  }
+
   async flushCheckpoint(): Promise<void> {
     if (this.checkpointDirty.size === 0) return
     const paths = [...this.checkpointDirty]
@@ -199,6 +204,57 @@ export function spaceR2Prefix(spaceId: string): string {
   return `spaces/v1/${spaceId}`
 }
 
+const R2_MULTIPART_CHUNK_BYTES = 5 * 1024 * 1024
+
+async function putStream(
+  bucket: R2Bucket,
+  key: string,
+  content: ReadableStream<Uint8Array>,
+  mediaType: string,
+): Promise<R2Object> {
+  const upload = await bucket.createMultipartUpload(key, {
+    httpMetadata: { contentType: mediaType },
+  })
+  const uploaded: R2UploadedPart[] = []
+  const reader = content.getReader()
+  let buffer = new Uint8Array(R2_MULTIPART_CHUNK_BYTES)
+  let buffered = 0
+  let partNumber = 1
+  const flush = async () => {
+    if (buffered === 0) return
+    uploaded.push(await upload.uploadPart(partNumber++, buffer.slice(0, buffered)))
+    buffer = new Uint8Array(R2_MULTIPART_CHUNK_BYTES)
+    buffered = 0
+  }
+  try {
+    while (true) {
+      const next = await reader.read()
+      if (next.done) break
+      let offset = 0
+      while (offset < next.value.byteLength) {
+        const copied = Math.min(buffer.byteLength - buffered, next.value.byteLength - offset)
+        buffer.set(next.value.subarray(offset, offset + copied), buffered)
+        buffered += copied
+        offset += copied
+        if (buffered === buffer.byteLength) await flush()
+      }
+    }
+    await flush()
+    if (uploaded.length === 0) {
+      await upload.abort()
+      return (await bucket.put(key, new Uint8Array(), {
+        httpMetadata: { contentType: mediaType },
+      }))
+    }
+    return upload.complete(uploaded)
+  } catch (error) {
+    await upload.abort().catch(() => undefined)
+    throw error
+  } finally {
+    reader.releaseLock()
+  }
+}
+
 export class SqlBackend implements SpaceFsBackend {
   readonly overlay: FileSystem
   readonly fs: FileSystem
@@ -212,7 +268,11 @@ export class SqlBackend implements SpaceFsBackend {
    * row will hold — and a Space that fills its DO storage stops accepting
    * writes for every other file too.
    */
-  constructor(ctx: DurableObjectState, repoName: string, r2?: R2Bucket) {
+  constructor(
+    private readonly ctx: DurableObjectState,
+    private readonly repoName: string,
+    private readonly r2?: R2Bucket,
+  ) {
     const workspace = new Workspace({
       sql: ctx.storage.sql,
       name: () => repoName,
@@ -229,6 +289,63 @@ export class SqlBackend implements SpaceFsBackend {
   async ready(): Promise<void> {}
   async hydrate(_path: string): Promise<void> {}
   async materializeAll(): Promise<void> {}
+  async writeFileStream(
+    path: string,
+    content: ReadableStream<Uint8Array>,
+    mediaType: string,
+  ): Promise<void> {
+    if (!this.r2) throw new Error("Streaming writes require an R2 binding")
+    await this.workspace.exists("/")
+    const existing = await this.workspace.stat(path)
+    if (existing?.type === "directory") throw new Error(`EISDIR: ${path} is a directory`)
+    const parent = path.slice(0, path.lastIndexOf("/")) || "/"
+    await this.workspace.mkdir(parent, { recursive: true })
+
+    // @cloudflare/shell@0.4.3 owns this table. Its public writeFileStream buffers;
+    // this adapter keeps the same row contract while R2 consumes the body stream.
+    const table = "cf_workspace_default"
+    const previous = this.ctx.storage.sql.exec<{ r2Key: string | null }>(
+      `SELECT r2_key AS r2Key FROM ${table} WHERE path = ?`,
+      path,
+    ).toArray()[0]
+    const key = `${spaceR2Prefix(this.repoName)}/streams/${crypto.randomUUID()}`
+    try {
+      const object = await putStream(this.r2, key, content, mediaType)
+      const name = path.split("/").at(-1)!
+      const now = Math.floor(Date.now() / 1_000)
+      this.ctx.storage.sql.exec(
+        `INSERT INTO ${table}
+           (path, parent_path, name, type, mime_type, size, storage_backend,
+            r2_key, content_encoding, content, created_at, modified_at)
+         VALUES (?, ?, ?, 'file', ?, ?, 'r2', ?, 'base64', NULL, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           parent_path = excluded.parent_path,
+           name = excluded.name,
+           type = 'file',
+           mime_type = excluded.mime_type,
+           size = excluded.size,
+           storage_backend = 'r2',
+           r2_key = excluded.r2_key,
+           content_encoding = 'base64',
+           content = NULL,
+           modified_at = excluded.modified_at`,
+        path,
+        parent,
+        name,
+        mediaType,
+        object.size,
+        key,
+        now,
+        now,
+      )
+    } catch (error) {
+      await this.r2.delete(key).catch(() => undefined)
+      throw error
+    }
+    if (previous?.r2Key && previous.r2Key !== key) {
+      await this.r2.delete(previous.r2Key).catch(() => undefined)
+    }
+  }
   async flushCheckpoint(): Promise<void> {}
   async push(_branch: string): Promise<boolean> { return false }
   async fetch(_branch: string): Promise<void> {}

package/src/space/workspace-port.ts

@@ -182,6 +182,11 @@ export interface SpaceWorkspacePort {
     data: Uint8Array | ArrayBuffer,
     mimeType?: string,
   ): Promise<void>;
+  writeFileStream(
+    path: string,
+    content: ReadableStream<Uint8Array>,
+    options?: SpaceStreamWriteOptions,
+  ): Promise<{ path: string; bytes: number }>;
   appendFile(path: string, content: string, mimeType?: string): Promise<void>;
   exists(path: string): Promise<boolean>;
   stat(path: string): Promise<SpaceFileInfo | null>;
@@ -199,6 +204,11 @@ export interface SpaceWorkspacePort {
   glob(pattern: string): Promise<SpaceFileInfo[]>;
 }
 
+export interface SpaceStreamWriteOptions {
+  contentLength?: number;
+  mediaType?: string;
+}
+
 /**
  * Everything a Space does that is not a file operation.
  *
@@ -255,7 +265,6 @@ export interface SpaceAppPort {
     revision?: string,
     runtimeConfig?: DeploymentRuntimeConfig,
   ): Promise<BranchDeploymentBundle>;
-  servePreview(branch: string, request: Request): Promise<Response>;
   serveApp(branch: string, request: Request): Promise<Response>;
   listAppTables(branch: string): Promise<unknown>;
   queryAppTable(branch: string, table: string, opts?: unknown): Promise<unknown>;