npm - @convex-dev/static-hosting - Versions diffs - 0.1.2-beta.0 - Mend

@convex-dev/static-hosting 0.1.2-beta.0

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 (98) hide show

package/LICENSE +201 -0
package/README.md +333 -0
package/dist/cli/deploy.d.ts +16 -0
package/dist/cli/deploy.d.ts.map +1 -0
package/dist/cli/deploy.js +324 -0
package/dist/cli/deploy.js.map +1 -0
package/dist/cli/index.d.ts +15 -0
package/dist/cli/index.d.ts.map +1 -0
package/dist/cli/index.js +95 -0
package/dist/cli/index.js.map +1 -0
package/dist/cli/init.d.ts +9 -0
package/dist/cli/init.d.ts.map +1 -0
package/dist/cli/init.js +181 -0
package/dist/cli/init.js.map +1 -0
package/dist/cli/next-build.d.ts +24 -0
package/dist/cli/next-build.d.ts.map +1 -0
package/dist/cli/next-build.js +569 -0
package/dist/cli/next-build.js.map +1 -0
package/dist/cli/setup.d.ts +9 -0
package/dist/cli/setup.d.ts.map +1 -0
package/dist/cli/setup.js +157 -0
package/dist/cli/setup.js.map +1 -0
package/dist/cli/upload.d.ts +15 -0
package/dist/cli/upload.d.ts.map +1 -0
package/dist/cli/upload.js +436 -0
package/dist/cli/upload.js.map +1 -0
package/dist/client/_generated/_ignore.d.ts +1 -0
package/dist/client/_generated/_ignore.d.ts.map +1 -0
package/dist/client/_generated/_ignore.js +3 -0
package/dist/client/_generated/_ignore.js.map +1 -0
package/dist/client/index.d.ts +142 -0
package/dist/client/index.d.ts.map +1 -0
package/dist/client/index.js +475 -0
package/dist/client/index.js.map +1 -0
package/dist/client/next.d.ts +38 -0
package/dist/client/next.d.ts.map +1 -0
package/dist/client/next.js +175 -0
package/dist/client/next.js.map +1 -0
package/dist/client/nextAdapter.d.ts +4 -0
package/dist/client/nextAdapter.d.ts.map +1 -0
package/dist/client/nextAdapter.js +9 -0
package/dist/client/nextAdapter.js.map +1 -0
package/dist/component/_generated/api.d.ts +34 -0
package/dist/component/_generated/api.d.ts.map +1 -0
package/dist/component/_generated/api.js +31 -0
package/dist/component/_generated/api.js.map +1 -0
package/dist/component/_generated/component.d.ts +73 -0
package/dist/component/_generated/component.d.ts.map +1 -0
package/dist/component/_generated/component.js +11 -0
package/dist/component/_generated/component.js.map +1 -0
package/dist/component/_generated/dataModel.d.ts +46 -0
package/dist/component/_generated/dataModel.d.ts.map +1 -0
package/dist/component/_generated/dataModel.js +11 -0
package/dist/component/_generated/dataModel.js.map +1 -0
package/dist/component/_generated/server.d.ts +121 -0
package/dist/component/_generated/server.d.ts.map +1 -0
package/dist/component/_generated/server.js +78 -0
package/dist/component/_generated/server.js.map +1 -0
package/dist/component/convex.config.d.ts +3 -0
package/dist/component/convex.config.d.ts.map +1 -0
package/dist/component/convex.config.js +3 -0
package/dist/component/convex.config.js.map +1 -0
package/dist/component/lib.d.ts +88 -0
package/dist/component/lib.d.ts.map +1 -0
package/dist/component/lib.js +210 -0
package/dist/component/lib.js.map +1 -0
package/dist/component/schema.d.ts +27 -0
package/dist/component/schema.d.ts.map +1 -0
package/dist/component/schema.js +20 -0
package/dist/component/schema.js.map +1 -0
package/dist/react/index.d.ts +80 -0
package/dist/react/index.d.ts.map +1 -0
package/dist/react/index.js +138 -0
package/dist/react/index.js.map +1 -0
package/package.json +120 -0
package/src/cli/deploy.ts +375 -0
package/src/cli/index.ts +104 -0
package/src/cli/init.ts +181 -0
package/src/cli/next-build.ts +707 -0
package/src/cli/setup.ts +190 -0
package/src/cli/upload.ts +521 -0
package/src/client/_generated/_ignore.ts +1 -0
package/src/client/index.test.ts +67 -0
package/src/client/index.ts +553 -0
package/src/client/next.ts +223 -0
package/src/client/nextAdapter.ts +17 -0
package/src/client/setup.test.ts +26 -0
package/src/component/_generated/api.ts +50 -0
package/src/component/_generated/component.ts +104 -0
package/src/component/_generated/dataModel.ts +60 -0
package/src/component/_generated/server.ts +161 -0
package/src/component/convex.config.ts +3 -0
package/src/component/lib.test.ts +110 -0
package/src/component/lib.ts +228 -0
package/src/component/schema.ts +21 -0
package/src/component/setup.test.ts +11 -0
package/src/react/index.tsx +184 -0
package/src/test.ts +18 -0

package/src/client/index.test.ts ADDED Viewed

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "vitest";
+import { exposeUploadApi, getMimeType } from "./index.js";
+import { anyApi, type ApiFromModules } from "convex/server";
+import { components, initConvexTest } from "./setup.test.js";
+export const { generateUploadUrl, recordAsset, gcOldAssets, listAssets } =
+  exposeUploadApi(components.staticHosting);
+const testApi = (
+  anyApi as unknown as ApiFromModules<{
+    "index.test": {
+      generateUploadUrl: typeof generateUploadUrl;
+      recordAsset: typeof recordAsset;
+      gcOldAssets: typeof gcOldAssets;
+      listAssets: typeof listAssets;
+    };
+  }>
+)["index.test"];
+describe("client tests", () => {
+  test("should expose upload API functions", async () => {
+    const t = initConvexTest();
+    // Test generateUploadUrl
+    const uploadUrl = await t.mutation(testApi.generateUploadUrl, {});
+    expect(uploadUrl).toBeDefined();
+    expect(typeof uploadUrl).toBe("string");
+  });
+  test("should list empty assets initially", async () => {
+    const t = initConvexTest();
+    const assets = await t.query(testApi.listAssets, {});
+    expect(assets).toHaveLength(0);
+  });
+  test("gc should return 0 with no assets", async () => {
+    const t = initConvexTest();
+    const result = await t.mutation(testApi.gcOldAssets, {
+      currentDeploymentId: "test-deployment",
+    });
+    expect(result.deleted).toBe(0);
+    expect(result.blobIds).toHaveLength(0);
+  });
+});
+describe("getMimeType", () => {
+  test("returns correct MIME types for common extensions", () => {
+    expect(getMimeType("/index.html")).toBe("text/html; charset=utf-8");
+    expect(getMimeType("/assets/main.js")).toBe(
+      "application/javascript; charset=utf-8",
+    );
+    expect(getMimeType("/styles/app.css")).toBe("text/css; charset=utf-8");
+    expect(getMimeType("/data.json")).toBe("application/json; charset=utf-8");
+    expect(getMimeType("/image.png")).toBe("image/png");
+    expect(getMimeType("/photo.jpg")).toBe("image/jpeg");
+    expect(getMimeType("/icon.svg")).toBe("image/svg+xml");
+    expect(getMimeType("/favicon.ico")).toBe("image/x-icon");
+    expect(getMimeType("/font.woff2")).toBe("font/woff2");
+  });
+  test("returns octet-stream for unknown extensions", () => {
+    expect(getMimeType("/file.xyz")).toBe("application/octet-stream");
+    expect(getMimeType("/unknown")).toBe("application/octet-stream");
+  });
+});

package/src/client/index.ts ADDED Viewed

@@ -0,0 +1,553 @@
+import {
+  httpActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+  queryGeneric,
+} from "convex/server";
+import type { HttpRouter } from "convex/server";
+import { v } from "convex/values";
+import type { ComponentApi } from "../component/_generated/component.js";
+// MIME type mapping for common file types
+const MIME_TYPES: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".txt": "text/plain; charset=utf-8",
+  ".map": "application/json",
+  ".webmanifest": "application/manifest+json",
+  ".xml": "application/xml",
+};
+/**
+ * Generate HTML page shown when no assets have been deployed yet.
+ */
+function getSetupHtml(): string {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Convex Static Hosting</title>
+  <style>
+    * { box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 640px;
+      margin: 0 auto;
+      padding: 40px 20px;
+      background: #fafafa;
+      color: #333;
+      line-height: 1.6;
+    }
+    h1 { color: #111; margin-bottom: 8px; }
+    .subtitle { color: #666; margin-bottom: 32px; }
+    code {
+      background: #e8e8e8;
+      padding: 2px 6px;
+      border-radius: 4px;
+      font-size: 14px;
+    }
+    pre {
+      background: #1a1a1a;
+      color: #f0f0f0;
+      padding: 16px;
+      border-radius: 8px;
+      overflow-x: auto;
+      font-size: 14px;
+    }
+    .step { margin-bottom: 24px; }
+    .step-num {
+      display: inline-block;
+      background: #333;
+      color: white;
+      width: 24px;
+      height: 24px;
+      border-radius: 50%;
+      text-align: center;
+      font-size: 14px;
+      line-height: 24px;
+      margin-right: 8px;
+    }
+    a { color: #0070f3; }
+  </style>
+</head>
+<body>
+  <h1>Almost there!</h1>
+  <p class="subtitle">Your Convex backend is running, but no static files have been deployed yet.</p>
+  <div class="step">
+    <span class="step-num">1</span>
+    <strong>Build your frontend</strong>
+    <pre>npm run build</pre>
+  </div>
+  <div class="step">
+    <span class="step-num">2</span>
+    <strong>Deploy your static files</strong>
+    <pre>npx @convex-dev/static-hosting deploy</pre>
+  </div>
+  <p>Or deploy everything in one command:</p>
+  <pre>npm run deploy</pre>
+  <p style="margin-top: 32px; color: #666; font-size: 14px;">
+    Learn more at <a href="https://github.com/get-convex/static-hosting">github.com/get-convex/static-hosting</a>
+  </p>
+</body>
+</html>`;
+}
+/**
+ * Get MIME type for a file path based on its extension.
+ */
+export function getMimeType(path: string): string {
+  const ext = path.substring(path.lastIndexOf(".")).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+/**
+ * Check if a path has a file extension.
+ */
+function hasFileExtension(path: string): boolean {
+  const lastSegment = path.split("/").pop() || "";
+  return lastSegment.includes(".") && !lastSegment.startsWith(".");
+}
+/**
+ * Check if asset is a hashed asset (for cache control).
+ * Vite produces: index-lj_vq_aF.js, style-B71cUw87.css
+ */
+function isHashedAsset(path: string): boolean {
+  return /[-.][\dA-Za-z_]{6,12}\.[a-z]+$/.test(path);
+}
+/**
+ * Register HTTP routes for serving static files.
+ * This creates a catch-all route that serves files from Convex storage
+ * with SPA fallback support.
+ *
+ * @param http - The HTTP router to register routes on
+ * @param component - The component API reference
+ * @param options - Configuration options
+ * @param options.pathPrefix - URL prefix for static files (default: "/")
+ * @param options.spaFallback - Enable SPA fallback to index.html (default: true)
+ *
+ * @example
+ * ```typescript
+ * // In your convex/http.ts
+ * import { httpRouter } from "convex/server";
+ * import { registerStaticRoutes } from "@convex-dev/static-hosting";
+ * import { components } from "./_generated/api";
+ *
+ * const http = httpRouter();
+ *
+ * // Serve static files at root
+ * registerStaticRoutes(http, components.staticHosting);
+ *
+ * // Or serve at a specific path prefix
+ * registerStaticRoutes(http, components.staticHosting, {
+ *   pathPrefix: "/app",
+ * });
+ *
+ * export default http;
+ * ```
+ */
+/**
+ * Check if a content type is HTML.
+ */
+function isHtmlContentType(contentType: string): boolean {
+  return contentType.startsWith("text/html");
+}
+export function registerStaticRoutes(
+  http: HttpRouter,
+  component: ComponentApi,
+  {
+    pathPrefix = "/",
+    spaFallback = true,
+    cdnBaseUrl,
+  }: {
+    pathPrefix?: string;
+    spaFallback?: boolean;
+    /** Base URL for CDN blob redirects (e.g., `(req) => \`${new URL(req.url).origin}/fs/blobs\``).
+     * When set, assets with a blobId (non-HTML) will return a 302 redirect to `{cdnBaseUrl}/{blobId}`. */
+    cdnBaseUrl?: string | ((request: Request) => string);
+  } = {},
+) {
+  // Normalize pathPrefix - ensure it starts with / and doesn't end with /
+  const normalizedPrefix =
+    pathPrefix === "/" ? "" : pathPrefix.replace(/\/$/, "");
+  const serveStaticFile = httpActionGeneric(async (ctx, request) => {
+    const url = new URL(request.url);
+    let path = url.pathname;
+    // Remove prefix if present
+    if (normalizedPrefix && path.startsWith(normalizedPrefix)) {
+      path = path.slice(normalizedPrefix.length) || "/";
+    }
+    // Normalize: serve index.html for root
+    if (path === "" || path === "/") {
+      path = "/index.html";
+    }
+    // Look up the asset
+    type AssetDoc = {
+      _id: string;
+      _creationTime: number;
+      path: string;
+      storageId?: string;
+      blobId?: string;
+      contentType: string;
+      deploymentId: string;
+    } | null;
+    let asset: AssetDoc = await ctx.runQuery(component.lib.getByPath, { path });
+    // SPA fallback: if not found and no file extension, serve index.html
+    if (!asset && spaFallback && !hasFileExtension(path)) {
+      asset = await ctx.runQuery(component.lib.getByPath, {
+        path: "/index.html",
+      });
+    }
+    // 404 if still not found
+    if (!asset) {
+      // If looking for index.html and it's not there, show setup instructions
+      if (path === "/index.html") {
+        return new Response(getSetupHtml(), {
+          status: 200,
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+      }
+      return new Response("Not Found", {
+        status: 404,
+        headers: { "Content-Type": "text/plain" },
+      });
+    }
+    // CDN redirect: if asset has blobId, is not HTML, and cdnBaseUrl is configured
+    if (asset.blobId && cdnBaseUrl && !isHtmlContentType(asset.contentType)) {
+      const baseUrl =
+        typeof cdnBaseUrl === "function" ? cdnBaseUrl(request) : cdnBaseUrl;
+      const redirectUrl = `${baseUrl.replace(/\/$/, "")}/${asset.blobId}`;
+      // Cache control for redirect: hashed assets can cache the redirect itself
+      const cacheControl = isHashedAsset(path)
+        ? "public, max-age=31536000, immutable"
+        : "public, max-age=0, must-revalidate";
+      return new Response(null, {
+        status: 302,
+        headers: {
+          Location: redirectUrl,
+          "Cache-Control": cacheControl,
+        },
+      });
+    }
+    // Serve from Convex storage
+    if (!asset.storageId) {
+      return new Response("Asset not available", {
+        status: 500,
+        headers: { "Content-Type": "text/plain" },
+      });
+    }
+    // Use storageId as ETag (unique per file content)
+    const etag = `"${asset.storageId}"`;
+    // Check for conditional request (If-None-Match)
+    const ifNoneMatch = request.headers.get("If-None-Match");
+    if (ifNoneMatch === etag) {
+      // Client has current version - return 304 Not Modified
+      return new Response(null, {
+        status: 304,
+        headers: {
+          ETag: etag,
+          "Cache-Control": isHashedAsset(path)
+            ? "public, max-age=31536000, immutable"
+            : "public, max-age=0, must-revalidate",
+        },
+      });
+    }
+    // Get file from storage
+    const blob = await ctx.storage.get(asset.storageId);
+    if (!blob) {
+      return new Response("Storage error", {
+        status: 500,
+        headers: { "Content-Type": "text/plain" },
+      });
+    }
+    // Cache control: hashed assets can be cached forever
+    const cacheControl = isHashedAsset(path)
+      ? "public, max-age=31536000, immutable"
+      : "public, max-age=0, must-revalidate";
+    return new Response(blob, {
+      status: 200,
+      headers: {
+        "Content-Type": asset.contentType,
+        "Cache-Control": cacheControl,
+        ETag: etag,
+        "X-Content-Type-Options": "nosniff",
+      },
+    });
+  });
+  // Use pathPrefix routing
+  http.route({
+    pathPrefix: pathPrefix === "/" ? "/" : `${normalizedPrefix}/`,
+    method: "GET",
+    handler: serveStaticFile,
+  });
+  // Also handle exact prefix without trailing slash
+  if (normalizedPrefix) {
+    http.route({
+      path: normalizedPrefix,
+      method: "GET",
+      handler: serveStaticFile,
+    });
+  }
+}
+/**
+ * Expose the upload API as INTERNAL functions for secure deployments.
+ * These functions can only be called via `npx convex run` or from other Convex functions.
+ *
+ * @param component - The component API reference
+ *
+ * @example
+ * ```typescript
+ * // In your convex/staticHosting.ts
+ * import { exposeUploadApi } from "@convex-dev/static-hosting";
+ * import { components } from "./_generated/api";
+ *
+ * export const { generateUploadUrl, recordAsset, gcOldAssets, listAssets } =
+ *   exposeUploadApi(components.staticHosting);
+ * ```
+ *
+ * Then deploy using:
+ * ```bash
+ * npm run deploy:static
+ * ```
+ */
+export function exposeUploadApi(component: ComponentApi) {
+  return {
+    /**
+     * Generate a signed URL for uploading a file.
+     * Files are stored in the app's storage (not the component's).
+     */
+    generateUploadUrl: internalMutationGeneric({
+      args: {},
+      handler: async (ctx) => {
+        return await ctx.storage.generateUploadUrl();
+      },
+    }),
+    /**
+     * Record an uploaded asset in the database.
+     * Automatically cleans up old storage files when replacing.
+     * Pass storageId for Convex storage assets, or blobId for CDN assets.
+     */
+    recordAsset: internalMutationGeneric({
+      args: {
+        path: v.string(),
+        storageId: v.optional(v.string()),
+        blobId: v.optional(v.string()),
+        contentType: v.string(),
+        deploymentId: v.string(),
+      },
+      handler: async (ctx, args) => {
+        const { oldStorageId, oldBlobId } = await ctx.runMutation(
+          component.lib.recordAsset,
+          {
+            path: args.path,
+            ...(args.storageId ? { storageId: args.storageId } : {}),
+            ...(args.blobId ? { blobId: args.blobId } : {}),
+            contentType: args.contentType,
+            deploymentId: args.deploymentId,
+          },
+        );
+        if (oldStorageId) {
+          try {
+            await ctx.storage.delete(oldStorageId);
+          } catch {
+            // Ignore - old file may have been in different storage
+          }
+        }
+        // Return oldBlobId so caller can clean up CDN blobs if needed
+        return oldBlobId ?? null;
+      },
+    }),
+    /**
+     * Garbage collect old assets and notify clients of the new deployment.
+     * Returns the count of deleted assets.
+     * Also triggers connected clients to reload via the deployment subscription.
+     */
+    gcOldAssets: internalMutationGeneric({
+      args: {
+        currentDeploymentId: v.string(),
+      },
+      handler: async (ctx, args) => {
+        const { storageIds, blobIds } = await ctx.runMutation(
+          component.lib.gcOldAssets,
+          {
+            currentDeploymentId: args.currentDeploymentId,
+          },
+        );
+        for (const storageId of storageIds) {
+          try {
+            await ctx.storage.delete(storageId);
+          } catch {
+            // Ignore - old file may have been in different storage
+          }
+        }
+        // Update deployment info to trigger client reloads
+        await ctx.runMutation(component.lib.setCurrentDeployment, {
+          deploymentId: args.currentDeploymentId,
+        });
+        // Return both counts and blobIds for CDN cleanup
+        return { deleted: storageIds.length, blobIds };
+      },
+    }),
+    /**
+     * Generate multiple signed upload URLs in one call.
+     * Much faster than calling generateUploadUrl N times.
+     */
+    generateUploadUrls: internalMutationGeneric({
+      args: { count: v.number() },
+      handler: async (ctx, { count }) => {
+        const urls: string[] = [];
+        for (let i = 0; i < count; i++) {
+          urls.push(await ctx.storage.generateUploadUrl());
+        }
+        return urls;
+      },
+    }),
+    /**
+     * Record multiple uploaded assets in one call.
+     */
+    recordAssets: internalMutationGeneric({
+      args: {
+        assets: v.array(
+          v.object({
+            path: v.string(),
+            storageId: v.string(),
+            contentType: v.string(),
+            deploymentId: v.string(),
+          }),
+        ),
+      },
+      handler: async (ctx, { assets }) => {
+        for (const asset of assets) {
+          await ctx.runMutation(component.lib.recordAsset, {
+            path: asset.path,
+            storageId: asset.storageId,
+            contentType: asset.contentType,
+            deploymentId: asset.deploymentId,
+          });
+        }
+      },
+    }),
+    /**
+     * List all static assets (for debugging).
+     */
+    listAssets: internalQueryGeneric({
+      args: {
+        limit: v.optional(v.number()),
+      },
+      handler: async (ctx, args) => {
+        return await ctx.runQuery(component.lib.listAssets, {
+          limit: args.limit,
+        });
+      },
+    }),
+  };
+}
+/**
+ * Expose a query that clients can subscribe to for live reload on deploy.
+ * When a new deployment happens, subscribed clients will be notified.
+ *
+ * @param component - The component API reference
+ *
+ * @example
+ * ```typescript
+ * // In your convex/staticHosting.ts
+ * import { exposeUploadApi, exposeDeploymentQuery } from "@convex-dev/static-hosting";
+ * import { components } from "./_generated/api";
+ *
+ * export const { generateUploadUrl, recordAsset, gcOldAssets, listAssets } =
+ *   exposeUploadApi(components.staticHosting);
+ *
+ * export const { getCurrentDeployment } = exposeDeploymentQuery(components.staticHosting);
+ * ```
+ */
+export function exposeDeploymentQuery(component: ComponentApi) {
+  return {
+    /**
+     * Get the current deployment info.
+     * Subscribe to this query to detect when a new deployment happens.
+     */
+    getCurrentDeployment: queryGeneric({
+      args: {},
+      handler: async (ctx) => {
+        return await ctx.runQuery(component.lib.getCurrentDeployment, {});
+      },
+    }),
+  };
+}
+/**
+ * Derive the Convex cloud URL from a .convex.site hostname.
+ * Useful for client-side code that needs to connect to the Convex backend
+ * when hosted on Convex static hosting.
+ *
+ * @example
+ * ```typescript
+ * // In your React app's main.tsx
+ * import { getConvexUrl } from "@convex-dev/static-hosting";
+ *
+ * const convexUrl = import.meta.env.VITE_CONVEX_URL ?? getConvexUrl();
+ * const convex = new ConvexReactClient(convexUrl);
+ * ```
+ */
+export function getConvexUrl(): string {
+  if (typeof window === "undefined") {
+    throw new Error("getConvexUrl() can only be called in a browser context");
+  }
+  // If hosted on Convex (.convex.site), derive API URL (.convex.cloud)
+  if (window.location.hostname.endsWith(".convex.site")) {
+    return `https://${window.location.hostname.replace(".convex.site", ".convex.cloud")}`;
+  }
+  throw new Error(
+    "Unable to derive Convex URL. Please set VITE_CONVEX_URL environment variable.",
+  );
+}