@jant/core 0.3.8 → 0.3.9

package/dist/app.js

@@ -40,6 +40,7 @@ import { requireOnboarding } from "./middleware/onboarding.js";
 import { BaseLayout } from "./theme/layouts/index.js";
 import { dsRedirect, dsToast } from "./lib/sse.js";
 import { getAvailableThemes, buildThemeStyle } from "./lib/theme.js";
+import { createStorageDriver } from "./lib/storage.js";
 /**
  * Create a Jant application
  *
@@ -72,6 +73,7 @@ import { getAvailableThemes, buildThemeStyle } from "./lib/theme.js";
         const services = createServices(db, session);
         c.set("services", services);
         c.set("config", config);
+        c.set("storage", createStorageDriver(c.env));
         if (c.env.AUTH_SECRET) {
             const auth = createAuth(session, {
                 secret: c.env.AUTH_SECRET,
@@ -633,9 +635,10 @@ import { getAvailableThemes, buildThemeStyle } from "./lib/theme.js";
     // API routes
     app.route("/api/upload", uploadApiRoutes);
     app.route("/api/search", searchApiRoutes);
-    // Media files from R2 (UUIDv7-based URLs with extension)
+    // Media files from storage (UUIDv7-based URLs with extension)
     app.get("/media/:idWithExt", async (c)=>{
-        if (!c.env.R2) {
+        const storage = c.var.storage;
+        if (!storage) {
             return c.notFound();
         }
         // Extract ID from "uuid.ext" format
@@ -645,12 +648,12 @@ import { getAvailableThemes, buildThemeStyle } from "./lib/theme.js";
         if (!media) {
             return c.notFound();
         }
-        const object = await c.env.R2.get(media.r2Key);
+        const object = await storage.get(media.storageKey);
         if (!object) {
             return c.notFound();
         }
         const headers = new Headers();
-        headers.set("Content-Type", object.httpMetadata?.contentType || media.mimeType);
+        headers.set("Content-Type", object.contentType || media.mimeType);
         headers.set("Cache-Control", "public, max-age=31536000, immutable");
         return new Response(object.body, {
             headers

package/dist/db/schema.js

@@ -52,7 +52,8 @@ export const media = sqliteTable("media", {
     originalName: text("original_name").notNull(),
     mimeType: text("mime_type").notNull(),
     size: integer("size").notNull(),
-    r2Key: text("r2_key").notNull(),
+    storageKey: text("storage_key").notNull(),
+    provider: text("provider").notNull().default("r2"),
     width: integer("width"),
     height: integer("height"),
     alt: text("alt"),

package/dist/lib/image.js

@@ -46,32 +46,56 @@
     }
     return `${transformUrl}/${params.join(",")}/${originalUrl}`;
 }
+/**
+ * Returns the appropriate public URL base for a given storage provider.
+ *
+ * For `"s3"` provider, returns `s3PublicUrl`. For all other providers
+ * (including `"r2"`), returns `r2PublicUrl`. Falls back to `undefined`
+ * if the matching URL is not configured.
+ *
+ * @param provider - The storage provider identifier (e.g., `"r2"`, `"s3"`)
+ * @param r2PublicUrl - Optional R2 public URL
+ * @param s3PublicUrl - Optional S3 public URL
+ * @returns The public URL base for the provider, or undefined
+ *
+ * @example
+ * ```ts
+ * getPublicUrlForProvider("r2", "https://r2.example.com", "https://s3.example.com");
+ * // Returns: "https://r2.example.com"
+ *
+ * getPublicUrlForProvider("s3", "https://r2.example.com", "https://s3.example.com");
+ * // Returns: "https://s3.example.com"
+ * ```
+ */ export function getPublicUrlForProvider(provider, r2PublicUrl, s3PublicUrl) {
+    if (provider === "s3") return s3PublicUrl;
+    return r2PublicUrl;
+}
 /**
  * Generates a media URL using UUIDv7-based paths.
  *
- * Returns a public URL for a media file. If `r2PublicUrl` is set, uses that directly
- * with the r2Key. Otherwise, generates a `/media/{id}.{ext}` URL.
+ * Returns a public URL for a media file. If `publicUrl` is set, uses that directly
+ * with the storage key. Otherwise, generates a `/media/{id}.{ext}` local proxy URL.
  *
  * @param mediaId - The UUIDv7 database ID of the media
- * @param r2Key - The R2 storage key (used to extract extension)
- * @param r2PublicUrl - Optional R2 public URL for direct CDN access
+ * @param storageKey - The storage object key (used to build CDN path and extract extension)
+ * @param publicUrl - Optional public URL base for direct CDN access
  * @returns The public URL for the media file
  *
  * @example
  * ```ts
- * // Without R2 public URL - uses UUID with extension
- * getMediaUrl("01902a9f-1a2b-7c3d-8e4f-5a6b7c8d9e0f", "media/2025/01/01902a9f-1a2b-7c3d-8e4f-5a6b7c8d9e0f.webp");
- * // Returns: "/media/01902a9f-1a2b-7c3d-8e4f-5a6b7c8d9e0f.webp"
+ * // Without public URL - uses local proxy with UUID and extension
+ * getMediaUrl("01902a9f-1a2b-7c3d", "media/2025/01/01902a9f-1a2b-7c3d.webp");
+ * // Returns: "/media/01902a9f-1a2b-7c3d.webp"
  *
- * // With R2 public URL - uses direct CDN
- * getMediaUrl("01902a9f-1a2b-7c3d-8e4f-5a6b7c8d9e0f", "media/2025/01/01902a9f-1a2b-7c3d-8e4f-5a6b7c8d9e0f.webp", "https://cdn.example.com");
- * // Returns: "https://cdn.example.com/media/2025/01/01902a9f-1a2b-7c3d-8e4f-5a6b7c8d9e0f.webp"
+ * // With public URL - uses direct CDN
+ * getMediaUrl("01902a9f-1a2b-7c3d", "media/2025/01/01902a9f-1a2b-7c3d.webp", "https://cdn.example.com");
+ * // Returns: "https://cdn.example.com/media/2025/01/01902a9f-1a2b-7c3d.webp"
  * ```
- */ export function getMediaUrl(mediaId, r2Key, r2PublicUrl) {
-    if (r2PublicUrl) {
-        return `${r2PublicUrl}/${r2Key}`;
+ */ export function getMediaUrl(mediaId, storageKey, publicUrl) {
+    if (publicUrl) {
+        return `${publicUrl.replace(/\/+$/, "")}/${storageKey}`;
     }
-    // Extract extension from r2Key
-    const ext = r2Key.split(".").pop() || "bin";
+    // Extract extension from storage key
+    const ext = storageKey.split(".").pop() || "bin";
     return `/media/${mediaId}.${ext}`;
 }

package/dist/lib/media-helpers.js

@@ -2,30 +2,35 @@
  * Media Helper Utilities
  *
  * Shared logic for building MediaAttachment maps from raw media data.
- */ import { getMediaUrl, getImageUrl } from "./image.js";
+ */ import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "./image.js";
 /**
  * Builds a map of post IDs to MediaAttachment arrays from raw media data.
  *
- * Transforms raw Media objects (with R2 keys) into MediaAttachment objects
+ * Transforms raw Media objects (with storage keys) into MediaAttachment objects
  * (with public URLs and preview URLs) suitable for rendering.
+ * Automatically resolves the correct public URL based on each media item's
+ * storage provider (`"r2"` or `"s3"`).
  *
  * @param rawMediaMap - Map of post IDs to raw Media arrays from the media service
  * @param r2PublicUrl - Optional R2 public URL for direct CDN access
  * @param imageTransformUrl - Optional image transformation service URL
+ * @param s3PublicUrl - Optional S3 public URL for direct CDN access
  * @returns Map of post IDs to MediaAttachment arrays
  *
  * @example
  * ```ts
  * const rawMediaMap = await services.media.getByPostIds(postIds);
- * const mediaMap = buildMediaMap(rawMediaMap, c.env.R2_PUBLIC_URL, c.env.IMAGE_TRANSFORM_URL);
+ * const mediaMap = buildMediaMap(rawMediaMap, c.env.R2_PUBLIC_URL, c.env.IMAGE_TRANSFORM_URL, c.env.S3_PUBLIC_URL);
  * ```
- */ export function buildMediaMap(rawMediaMap, r2PublicUrl, imageTransformUrl) {
+ */ export function buildMediaMap(rawMediaMap, r2PublicUrl, imageTransformUrl, s3PublicUrl) {
     const mediaMap = new Map();
     for (const [postId, mediaList] of rawMediaMap){
-        mediaMap.set(postId, mediaList.map((m)=>({
+        mediaMap.set(postId, mediaList.map((m)=>{
+            const publicUrl = getPublicUrlForProvider(m.provider, r2PublicUrl, s3PublicUrl);
+            return {
                 id: m.id,
-                url: getMediaUrl(m.id, m.r2Key, r2PublicUrl),
-                previewUrl: getImageUrl(getMediaUrl(m.id, m.r2Key, r2PublicUrl), imageTransformUrl, {
+                url: getMediaUrl(m.id, m.storageKey, publicUrl),
+                previewUrl: getImageUrl(getMediaUrl(m.id, m.storageKey, publicUrl), imageTransformUrl, {
                     width: 400,
                     quality: 80,
                     format: "auto",
@@ -37,7 +42,8 @@
                 height: m.height,
                 position: m.position,
                 mimeType: m.mimeType
-            })));
+            };
+        }));
     }
     return mediaMap;
 }

package/dist/lib/storage.js

@@ -0,0 +1,164 @@
+/**
+ * Storage Driver Abstraction
+ *
+ * Provides a common interface for file storage with R2 and S3-compatible backends.
+ */ /**
+ * Creates an R2 storage driver that delegates to a Cloudflare R2 bucket binding.
+ *
+ * @param r2 - The R2 bucket binding from the Cloudflare Workers environment
+ * @returns A StorageDriver backed by R2
+ */ export function createR2Driver(r2) {
+    return {
+        async put (key, body, opts) {
+            await r2.put(key, body, {
+                httpMetadata: opts?.contentType ? {
+                    contentType: opts.contentType
+                } : undefined
+            });
+        },
+        async get (key) {
+            const object = await r2.get(key);
+            if (!object) return null;
+            return {
+                body: object.body,
+                contentType: object.httpMetadata?.contentType ?? undefined
+            };
+        },
+        async delete (key) {
+            await r2.delete(key);
+        }
+    };
+}
+/**
+ * Creates an S3-compatible storage driver using the AWS SDK.
+ *
+ * Supports any S3-compatible service: AWS S3, Backblaze B2, MinIO, etc.
+ * Uses path-style addressing for non-AWS endpoints.
+ *
+ * @param config - S3 connection configuration
+ * @returns A StorageDriver backed by S3
+ */ export function createS3Driver(config) {
+    // Lazy-load the AWS SDK to avoid bundling it when using R2
+    let clientPromise = null;
+    function getClient() {
+        if (!clientPromise) {
+            clientPromise = import("@aws-sdk/client-s3").then((sdk)=>{
+                const forcePathStyle = !config.endpoint.includes("amazonaws.com");
+                const client = new sdk.S3Client({
+                    endpoint: config.endpoint,
+                    region: config.region,
+                    credentials: {
+                        accessKeyId: config.accessKeyId,
+                        secretAccessKey: config.secretAccessKey
+                    },
+                    forcePathStyle
+                });
+                return {
+                    send: (cmd)=>client.send(cmd),
+                    S3Client: sdk.S3Client,
+                    PutObjectCommand: sdk.PutObjectCommand,
+                    GetObjectCommand: sdk.GetObjectCommand,
+                    DeleteObjectCommand: sdk.DeleteObjectCommand,
+                    bucket: config.bucket
+                };
+            });
+        }
+        return clientPromise;
+    }
+    return {
+        async put (key, body, opts) {
+            const s3 = await getClient();
+            // Buffer the stream to Uint8Array for the S3 SDK
+            let bodyBytes;
+            if (body instanceof Uint8Array) {
+                bodyBytes = body;
+            } else {
+                const reader = body.getReader();
+                const chunks = [];
+                for(;;){
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    chunks.push(value);
+                }
+                let totalLength = 0;
+                for (const chunk of chunks)totalLength += chunk.length;
+                bodyBytes = new Uint8Array(totalLength);
+                let offset = 0;
+                for (const chunk of chunks){
+                    bodyBytes.set(chunk, offset);
+                    offset += chunk.length;
+                }
+            }
+            const command = new s3.PutObjectCommand({
+                Bucket: s3.bucket,
+                Key: key,
+                Body: bodyBytes,
+                ContentType: opts?.contentType
+            });
+            await s3.send(command);
+        },
+        async get (key) {
+            const s3 = await getClient();
+            try {
+                const command = new s3.GetObjectCommand({
+                    Bucket: s3.bucket,
+                    Key: key
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- AWS SDK response type
+                const response = await s3.send(command);
+                if (!response.Body) return null;
+                return {
+                    body: response.Body.transformToWebStream(),
+                    contentType: response.ContentType ?? undefined
+                };
+            } catch (err) {
+                // NoSuchKey → return null instead of throwing
+                if (err instanceof Error && (err.name === "NoSuchKey" || err.name === "NotFound")) {
+                    return null;
+                }
+                throw err;
+            }
+        },
+        async delete (key) {
+            const s3 = await getClient();
+            const command = new s3.DeleteObjectCommand({
+                Bucket: s3.bucket,
+                Key: key
+            });
+            await s3.send(command);
+        }
+    };
+}
+/**
+ * Creates the appropriate storage driver based on environment configuration.
+ *
+ * Returns `null` if no storage is configured (no R2 binding and no S3 config).
+ *
+ * @param env - The Cloudflare Workers environment bindings
+ * @returns A StorageDriver instance or null
+ *
+ * @example
+ * ```ts
+ * const storage = createStorageDriver(c.env);
+ * if (storage) {
+ *   await storage.put("media/file.jpg", stream, { contentType: "image/jpeg" });
+ * }
+ * ```
+ */ export function createStorageDriver(env) {
+    const driver = env.STORAGE_DRIVER || "r2";
+    if (driver === "s3") {
+        if (!env.S3_ENDPOINT || !env.S3_BUCKET || !env.S3_ACCESS_KEY_ID || !env.S3_SECRET_ACCESS_KEY) {
+            return null;
+        }
+        return createS3Driver({
+            endpoint: env.S3_ENDPOINT,
+            bucket: env.S3_BUCKET,
+            accessKeyId: env.S3_ACCESS_KEY_ID,
+            secretAccessKey: env.S3_SECRET_ACCESS_KEY,
+            region: env.S3_REGION || "auto"
+        });
+    }
+    // Default: R2
+    if (!env.R2) return null;
+    return createR2Driver(env.R2);
+}

package/dist/routes/api/posts.js

@@ -4,12 +4,13 @@
 import * as sqid from "../../lib/sqid.js";
 import { CreatePostSchema, UpdatePostSchema, validateMediaForPostType } from "../../lib/schemas.js";
 import { requireAuthApi } from "../../middleware/auth.js";
-import { getMediaUrl, getImageUrl } from "../../lib/image.js";
+import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "../../lib/image.js";
 export const postsApiRoutes = new Hono();
 /**
  * Converts a Media record to a MediaAttachment API response shape.
- */ function toMediaAttachment(m, r2PublicUrl, imageTransformUrl) {
-    const url = getMediaUrl(m.id, m.r2Key, r2PublicUrl);
+ */ function toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl) {
+    const publicUrl = getPublicUrlForProvider(m.provider, r2PublicUrl, s3PublicUrl);
+    const url = getMediaUrl(m.id, m.storageKey, publicUrl);
     const previewUrl = getImageUrl(url, imageTransformUrl, {
         width: 400,
         quality: 80,
@@ -50,11 +51,12 @@ postsApiRoutes.get("/", async (c)=>{
     const mediaMap = await c.var.services.media.getByPostIds(postIds);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         posts: posts.map((p)=>({
                 ...p,
                 sqid: sqid.encode(p.id),
-                mediaAttachments: (mediaMap.get(p.id) ?? []).map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl))
+                mediaAttachments: (mediaMap.get(p.id) ?? []).map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl))
             })),
         nextCursor: posts.length === limit ? sqid.encode(posts[posts.length - 1]?.id ?? 0) : null
     });
@@ -72,10 +74,11 @@ postsApiRoutes.get("/:id", async (c)=>{
     const mediaList = await c.var.services.media.getByPostId(post.id);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         ...post,
         sqid: sqid.encode(post.id),
-        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl))
+        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl))
     });
 });
 // Create post (requires auth)
@@ -126,10 +129,11 @@ postsApiRoutes.post("/", requireAuthApi(), async (c)=>{
     const mediaList = await c.var.services.media.getByPostId(post.id);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         ...post,
         sqid: sqid.encode(post.id),
-        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl))
+        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl))
     }, 201);
 });
 // Update post (requires auth)
@@ -195,10 +199,11 @@ postsApiRoutes.put("/:id", requireAuthApi(), async (c)=>{
     const mediaList = await c.var.services.media.getByPostId(post.id);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         ...post,
         sqid: sqid.encode(post.id),
-        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl))
+        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl))
     });
 });
 // Delete post (requires auth)

package/dist/routes/api/timeline.js

@@ -43,7 +43,8 @@ timelineApiRoutes.get("/", async (c)=>{
     const rawMediaMap = await c.var.services.media.getByPostIds(postIds);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
-    const mediaMap = buildMediaMap(rawMediaMap, r2PublicUrl, imageTransformUrl);
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
+    const mediaMap = buildMediaMap(rawMediaMap, r2PublicUrl, imageTransformUrl, s3PublicUrl);
     // Get reply counts to identify thread roots
     const replyCounts = await c.var.services.posts.getReplyCounts(postIds);
     const threadRootIds = postIds.filter((id)=>(replyCounts.get(id) ?? 0) > 0);
@@ -56,7 +57,7 @@ timelineApiRoutes.get("/", async (c)=>{
             previewReplyIds.push(reply.id);
         }
     }
-    const previewMediaMap = previewReplyIds.length > 0 ? buildMediaMap(await c.var.services.media.getByPostIds(previewReplyIds), r2PublicUrl, imageTransformUrl) : new Map();
+    const previewMediaMap = previewReplyIds.length > 0 ? buildMediaMap(await c.var.services.media.getByPostIds(previewReplyIds), r2PublicUrl, imageTransformUrl, s3PublicUrl) : new Map();
     // Assemble timeline items
     const items = displayPosts.map((post)=>{
         const postWithMedia = {

package/dist/routes/api/upload.js

@@ -7,15 +7,15 @@
 import { html } from "hono/html";
 import { uuidv7 } from "uuidv7";
 import { requireAuthApi } from "../../middleware/auth.js";
-import { getMediaUrl, getImageUrl } from "../../lib/image.js";
+import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "../../lib/image.js";
 import { sse, dsSignals } from "../../lib/sse.js";
 export const uploadApiRoutes = new Hono();
 // Require auth for all upload routes
 uploadApiRoutes.use("*", requireAuthApi());
 /**
  * Render a media card HTML string for SSE response
- */ function renderMediaCard(media, r2PublicUrl, imageTransformUrl) {
-    const fullUrl = getMediaUrl(media.id, media.r2Key, r2PublicUrl);
+ */ function renderMediaCard(media, publicUrl, imageTransformUrl) {
+    const fullUrl = getMediaUrl(media.id, media.storageKey, publicUrl);
     const thumbnailUrl = getImageUrl(fullUrl, imageTransformUrl, {
         width: 300,
         quality: 80,
@@ -87,14 +87,15 @@ function formatSize(bytes) {
 }
 // Upload a file
 uploadApiRoutes.post("/", async (c)=>{
-    if (!c.env.R2) {
+    const storage = c.var.storage;
+    if (!storage) {
         if (wantsSSE(c)) {
             return dsSignals({
-                _uploadError: "R2 storage not configured"
+                _uploadError: "Storage not configured"
             });
         }
         return c.json({
-            error: "R2 storage not configured"
+            error: "Storage not configured"
         }, 500);
     }
     const formData = await c.req.formData();
@@ -146,13 +147,11 @@ uploadApiRoutes.post("/", async (c)=>{
     const year = date.getUTCFullYear();
     const month = String(date.getUTCMonth() + 1).padStart(2, "0");
     const filename = `${id}.${ext}`;
-    const r2Key = `media/${year}/${month}/${filename}`;
+    const storageKey = `media/${year}/${month}/${filename}`;
     try {
-        // Upload to R2
-        await c.env.R2.put(r2Key, file.stream(), {
-            httpMetadata: {
-                contentType: file.type
-            }
+        // Upload to storage
+        await storage.put(storageKey, file.stream(), {
+            contentType: file.type
         });
         // Save to database
         const media = await c.var.services.media.create({
@@ -161,11 +160,14 @@ uploadApiRoutes.post("/", async (c)=>{
             originalName: file.name,
             mimeType: file.type,
             size: file.size,
-            r2Key
+            storageKey,
+            provider: c.env.STORAGE_DRIVER || "r2"
         });
         // SSE response for Datastar
         if (wantsSSE(c)) {
-            const cardHtml = renderMediaCard(media, c.env.R2_PUBLIC_URL, c.env.IMAGE_TRANSFORM_URL);
+            const provider = c.env.STORAGE_DRIVER || "r2";
+            const mediaPublicUrl = getPublicUrlForProvider(provider, c.env.R2_PUBLIC_URL, c.env.S3_PUBLIC_URL);
+            const cardHtml = renderMediaCard(media, mediaPublicUrl, c.env.IMAGE_TRANSFORM_URL);
             return sse(c, async (stream)=>{
                 // Replace placeholder with real media card
                 await stream.patchElements(cardHtml, {
@@ -176,7 +178,9 @@ uploadApiRoutes.post("/", async (c)=>{
             });
         }
         // JSON response for API clients
-        const publicUrl = getMediaUrl(media.id, r2Key, c.env.R2_PUBLIC_URL);
+        const provider = c.env.STORAGE_DRIVER || "r2";
+        const mediaPublicUrl = getPublicUrlForProvider(provider, c.env.R2_PUBLIC_URL, c.env.S3_PUBLIC_URL);
+        const publicUrl = getMediaUrl(media.id, storageKey, mediaPublicUrl);
         return c.json({
             id: media.id,
             filename: media.filename,
@@ -202,11 +206,13 @@ uploadApiRoutes.post("/", async (c)=>{
 uploadApiRoutes.get("/", async (c)=>{
     const limit = parseInt(c.req.query("limit") ?? "50", 10);
     const mediaList = await c.var.services.media.list(limit);
+    const r2PublicUrl = c.env.R2_PUBLIC_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         media: mediaList.map((m)=>({
                 id: m.id,
                 filename: m.filename,
-                url: getMediaUrl(m.id, m.r2Key, c.env.R2_PUBLIC_URL),
+                url: getMediaUrl(m.id, m.storageKey, getPublicUrlForProvider(m.provider, r2PublicUrl, s3PublicUrl)),
                 mimeType: m.mimeType,
                 size: m.size,
                 createdAt: m.createdAt
@@ -222,13 +228,14 @@ uploadApiRoutes.delete("/:id", async (c)=>{
             error: "Not found"
         }, 404);
     }
-    // Delete from R2
-    if (c.env.R2) {
+    // Delete from storage
+    const storage = c.var.storage;
+    if (storage) {
         try {
-            await c.env.R2.delete(media.r2Key);
+            await storage.delete(media.storageKey);
         } catch (err) {
             // eslint-disable-next-line no-console -- Error logging is intentional
-            console.error("R2 delete error:", err);
+            console.error("Storage delete error:", err);
         }
     }
     // Delete from database