deepspace 0.19.5 → 0.21.0

package/dist/index.js

@@ -587,6 +587,9 @@ var MSG = {
   CRON_PAUSE: "cron.pause",
   CRON_RESUME: "cron.resume",
   CRON_STATUS: "cron.status",
+  // Per-mutation receipt, sent only to the socket whose trigger/pause/
+  // resume carried a `requestId` — frames without one stay fire-and-forget.
+  CRON_ACK: "cron.ack",
   // ---- JobRoom ---------------------------------------------------------
   // Background-job queue with durable, alarm-driven execution. See
   // server/rooms/job-room.ts. Clients enqueue and subscribe to updates;
@@ -643,9 +646,9 @@ var clientBuild = {
   canvasUndo: () => ({ type: MSG.CANVAS_UNDO, payload: EMPTY }),
   canvasRedo: () => ({ type: MSG.CANVAS_REDO, payload: EMPTY }),
   // Cron
-  cronTrigger: (taskName) => ({ type: MSG.CRON_TRIGGER, payload: { taskName } }),
-  cronPause: (taskName) => ({ type: MSG.CRON_PAUSE, payload: { taskName } }),
-  cronResume: (taskName) => ({ type: MSG.CRON_RESUME, payload: { taskName } }),
+  cronTrigger: (taskName, requestId) => ({ type: MSG.CRON_TRIGGER, payload: { taskName, requestId } }),
+  cronPause: (taskName, requestId) => ({ type: MSG.CRON_PAUSE, payload: { taskName, requestId } }),
+  cronResume: (taskName, requestId) => ({ type: MSG.CRON_RESUME, payload: { taskName, requestId } }),
   // Jobs
   jobEnqueue: (requestId, type, payload, maxAttempts) => ({
     type: MSG.JOB_ENQUEUE,
@@ -699,6 +702,14 @@ var serverBuild = {
   cronTasks: (tasks) => ({ type: MSG.CRON_TASKS, payload: { tasks } }),
   cronHistory: (history) => ({ type: MSG.CRON_HISTORY, payload: { history } }),
   cronStatus: (tasks, recentHistory) => ({ type: MSG.CRON_STATUS, payload: { tasks, recentHistory } }),
+  cronAckSuccess: (requestId, taskName) => ({
+    type: MSG.CRON_ACK,
+    payload: { requestId, taskName, ok: true }
+  }),
+  cronAckFailure: (requestId, reason, error, taskName) => ({
+    type: MSG.CRON_ACK,
+    payload: { requestId, taskName, ok: false, reason, error }
+  }),
   // Jobs
   jobSnapshot: (jobs) => ({ type: MSG.JOB_UPDATE, payload: { kind: "snapshot", jobs } }),
   jobEnqueued: (job, requestId) => ({
@@ -950,7 +961,10 @@ import { useState } from "react";
 import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function AuthOverlay({
   onClose,
-  providers = ["github", "google"]
+  providers = ["github", "google"],
+  title = "Sign in to DeepSpace",
+  description = "Sync your data across devices",
+  logo
 } = {}) {
   const { isLoaded, isSignedIn } = useAuth();
   const [showEmailForm, setShowEmailForm] = useState(false);
@@ -996,7 +1010,7 @@ function AuthOverlay({
         onClick: onClose ? (e) => {
           if (e.target === e.currentTarget) onClose();
         } : void 0,
-        className: "fixed inset-0 z-[99999] flex items-center justify-center bg-black/55 backdrop-blur-2xl",
+        className: "fixed inset-0 z-[99999] flex items-center justify-center bg-[var(--ds-auth-backdrop,#0000008c)] backdrop-blur-2xl",
         style: {
           opacity: 0,
           animation: "ds-auth-overlay-in 0.4s ease forwards"
@@ -1020,8 +1034,9 @@ function AuthOverlay({
                   children: "\u2715"
                 }
               ),
-              /* @__PURE__ */ jsx2("h2", { className: "mb-2 text-[22px] font-bold leading-snug text-foreground", children: "Sign in to DeepSpace" }),
-              /* @__PURE__ */ jsx2("p", { className: "mb-6 text-sm leading-snug text-muted-foreground", children: "Sync your data across devices" }),
+              logo && /* @__PURE__ */ jsx2("div", { className: "mb-4 flex justify-center", children: logo }),
+              /* @__PURE__ */ jsx2("h2", { className: "mb-2 text-[22px] font-bold leading-snug text-foreground", children: title }),
+              /* @__PURE__ */ jsx2("p", { className: "mb-6 text-sm leading-snug text-muted-foreground", children: description }),
               /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-2", children: [
                 providers.includes("github") && /* @__PURE__ */ jsx2(OAuthButton, { onClick: () => handleSocial("github"), disabled: loading, icon: /* @__PURE__ */ jsx2(GitHubIcon, {}), children: "Continue with GitHub" }),
                 providers.includes("google") && /* @__PURE__ */ jsx2(OAuthButton, { onClick: () => handleSocial("google"), disabled: loading, icon: /* @__PURE__ */ jsx2(GoogleIcon, {}), children: "Continue with Google" })
@@ -3221,11 +3236,17 @@ function useCronMonitor(roomId) {
   const [history, setHistory] = useState9([]);
   const [connected, setConnected] = useState9(false);
   const [canWrite, setCanWrite] = useState9(false);
+  const [lastError, setLastError] = useState9(null);
   const wsRef = useRef10(null);
+  const pendingRef = useRef10(/* @__PURE__ */ new Map());
   useEffect12(() => {
     let ws = null;
     let reconnectTimer = null;
     let alive = true;
+    const drainPending = (result) => {
+      for (const resolve of pendingRef.current.values()) resolve(result);
+      pendingRef.current.clear();
+    };
     const connect = async () => {
       if (!alive) return;
       const token = await getAuthToken();
@@ -3250,6 +3271,17 @@ function useCronMonitor(roomId) {
           [MSG.CRON_STATUS]: (p) => {
             setTasks(p.tasks);
             setHistory(p.recentHistory);
+          },
+          [MSG.CRON_ACK]: (p) => {
+            const resolve = pendingRef.current.get(p.requestId);
+            if (!resolve) return;
+            pendingRef.current.delete(p.requestId);
+            resolve(
+              p.ok ? { ok: true, taskName: p.taskName, requestId: p.requestId } : { ok: false, reason: p.reason, error: p.error }
+            );
+          },
+          [MSG.ERROR]: (p) => {
+            setLastError(p.error);
           }
         });
       };
@@ -3257,6 +3289,7 @@ function useCronMonitor(roomId) {
         wsRef.current = null;
         setConnected(false);
         setCanWrite(false);
+        drainPending({ ok: false, reason: "not_connected" });
         if (alive) reconnectTimer = setTimeout(connect, 1e3);
       };
       ws.onerror = () => ws?.close();
@@ -3265,32 +3298,49 @@ function useCronMonitor(roomId) {
     return () => {
       alive = false;
       if (reconnectTimer) clearTimeout(reconnectTimer);
+      drainPending({ ok: false, reason: "not_connected" });
       ws?.close();
       wsRef.current = null;
     };
   }, [roomId]);
   const sendWrite = useCallback11(
-    (message) => {
-      if (!canWrite) return;
+    (build) => {
+      setLastError(null);
+      if (!canWrite) return Promise.resolve({ ok: false, reason: "read_only" });
       const ws = wsRef.current;
-      if (!ws || ws.readyState !== WebSocket.OPEN) return;
-      ws.send(encode(message));
+      if (!ws || ws.readyState !== WebSocket.OPEN) {
+        return Promise.resolve({ ok: false, reason: "not_connected" });
+      }
+      return new Promise((resolve) => {
+        const requestId = crypto.randomUUID();
+        pendingRef.current.set(requestId, resolve);
+        try {
+          ws.send(encode(build(requestId)));
+        } catch (e) {
+          pendingRef.current.delete(requestId);
+          resolve({
+            ok: false,
+            reason: "not_connected",
+            error: e instanceof Error ? e.message : String(e)
+          });
+        }
+      });
     },
     [canWrite]
   );
   const trigger = useCallback11(
-    (taskName) => sendWrite(clientBuild.cronTrigger(taskName)),
+    (taskName) => sendWrite((requestId) => clientBuild.cronTrigger(taskName, requestId)),
     [sendWrite]
   );
   const pause = useCallback11(
-    (taskName) => sendWrite(clientBuild.cronPause(taskName)),
+    (taskName) => sendWrite((requestId) => clientBuild.cronPause(taskName, requestId)),
     [sendWrite]
   );
   const resume = useCallback11(
-    (taskName) => sendWrite(clientBuild.cronResume(taskName)),
+    (taskName) => sendWrite((requestId) => clientBuild.cronResume(taskName, requestId)),
     [sendWrite]
   );
-  return { tasks, history, connected, canWrite, trigger, pause, resume };
+  return { tasks, history, connected, canWrite, lastError, trigger, pause, resume };
 }
 
 // src/client/storage/hooks/useJobs.ts
@@ -3548,13 +3598,13 @@ var MAX_UPLOAD_REQUEST_BYTES = 25 * 1024 * 1024;
 var UPLOAD_PART_BYTES = 20 * 1024 * 1024;
 var MAX_UPLOAD_PARTS = Math.ceil(MAX_APP_FILE_BYTES / UPLOAD_PART_BYTES);
 var MAX_BASE64_UPLOAD_BYTES = Math.floor(MAX_UPLOAD_REQUEST_BYTES * 3 / 4);
-function planUploadParts(totalBytes, partSize) {
+function planUploadParts(totalBytes) {
   const parts = [];
-  for (let start = 0; start < totalBytes; start += partSize) {
+  for (let start = 0; start < totalBytes; start += UPLOAD_PART_BYTES) {
     parts.push({
       partNumber: parts.length + 1,
       start,
-      end: Math.min(start + partSize, totalBytes)
+      end: Math.min(start + UPLOAD_PART_BYTES, totalBytes)
     });
   }
   return parts;
@@ -3627,24 +3677,43 @@ function resolveFile(fileOrKey) {
   }
   return { key: fileOrKey.key, name: fileOrKey.originalName };
 }
-async function uploadInParts(file, name, scopeParams, authHeaders, onProgress) {
+function withUploadKey(params, key) {
+  if (!key) return params;
+  const pair = `key=${encodeURIComponent(key)}`;
+  return params ? `${params}&${pair}` : pair;
+}
+async function uploadInParts(file, name, key, scopeParams, authHeaders, onProgress) {
   const headers = await authHeaders();
   const json = { ...headers, "Content-Type": "application/json" };
-  const initResponse = await fetch(`/api/files/multipart?${scopeParams}`, {
+  const requestId = crypto.randomUUID();
+  const initBody = JSON.stringify({
+    requestId,
+    name,
+    mimeType: file.type || "application/octet-stream",
+    size: file.size
+  });
+  const sendInit = () => fetch(`/api/files/multipart?${withUploadKey(scopeParams, key)}`, {
     method: "POST",
     headers: json,
-    body: JSON.stringify({ name, mimeType: file.type || "application/octet-stream", size: file.size })
+    body: initBody
   });
+  let initResponse = await sendInit().catch(() => null);
+  if (!initResponse || initResponse.status === 429 || initResponse.status >= 500) {
+    initResponse = await sendInit().catch(() => null);
+  }
+  if (!initResponse) {
+    return { success: false, error: "The files service could not be reached." };
+  }
   if (!initResponse.ok) return await readUploadResult(initResponse);
   const session = await initResponse.json();
-  if (!Number.isSafeInteger(session.partSize) || session.partSize < 1) {
+  if (!session.uploadId || !session.uploadKey || !session.reservationId || session.partSize !== UPLOAD_PART_BYTES) {
     return {
       success: false,
-      error: `The files service advertised an unusable part size (${session.partSize}).`
+      error: `The files service returned an unusable part size or multipart session (${session.partSize}).`
     };
   }
-  const query = `${scopeParams}&uploadKey=${encodeKeyPath(session.uploadKey)}&uploadId=${encodeURIComponent(session.uploadId)}`;
-  const plan = planUploadParts(file.size, session.partSize);
+  const query = `${scopeParams}&uploadKey=${encodeKeyPath(session.uploadKey)}&uploadId=${encodeURIComponent(session.uploadId)}&reservationId=${encodeURIComponent(session.reservationId)}`;
+  const plan = planUploadParts(file.size);
   const parts = [];
   let assembled = false;
   try {
@@ -3702,17 +3771,27 @@ function useR2Files(options) {
         if (tooBig) return tooBig;
         const fileName = name ?? (file instanceof File ? file.name : "upload");
         if (file.size > UPLOAD_PART_BYTES) {
-          return await uploadInParts(file, fileName, scopeParams, authHeaders, options2?.onProgress);
+          return await uploadInParts(
+            file,
+            fileName,
+            options2?.key,
+            scopeParams,
+            authHeaders,
+            options2?.onProgress
+          );
         }
         const headers = await authHeaders();
         const formData = new FormData();
         formData.append("file", file);
         if (name) formData.append("name", name);
-        const response = await fetch(`/api/files/upload?${scopeParams}`, {
-          method: "POST",
-          headers,
-          body: formData
-        });
+        const response = await fetch(
+          `/api/files/upload?${withUploadKey(scopeParams, options2?.key)}`,
+          {
+            method: "POST",
+            headers,
+            body: formData
+          }
+        );
         options2?.onProgress?.(file.size, file.size);
         return await readUploadResult(response);
       } catch (err) {
@@ -3724,20 +3803,20 @@ function useR2Files(options) {
     [scopeParams, authHeaders]
   );
   const uploadBase64 = useCallback14(
-    async (base64Data, name, mimeType) => {
+    async (base64Data, name, mimeType, options2) => {
       setIsUploading(true);
       try {
-        const tooBig = oversize(
-          Math.floor(base64Data.length * 3 / 4),
-          MAX_BASE64_UPLOAD_BYTES
-        );
+        const tooBig = oversize(Math.floor(base64Data.length * 3 / 4), MAX_BASE64_UPLOAD_BYTES);
         if (tooBig) return tooBig;
         const headers = await authHeaders();
-        const response = await fetch(`/api/files/upload?${scopeParams}`, {
-          method: "POST",
-          headers: { ...headers, "Content-Type": "application/json" },
-          body: JSON.stringify({ data: base64Data, name, mimeType })
-        });
+        const response = await fetch(
+          `/api/files/upload?${withUploadKey(scopeParams, options2?.key)}`,
+          {
+            method: "POST",
+            headers: { ...headers, "Content-Type": "application/json" },
+            body: JSON.stringify({ data: base64Data, name, mimeType })
+          }
+        );
         return await readUploadResult(response);
       } catch (err) {
         return { success: false, error: err instanceof Error ? err.message : "Upload failed" };
@@ -3747,12 +3826,18 @@ function useR2Files(options) {
     },
     [scopeParams, authHeaders]
   );
+  const getUrl = useCallback14(
+    (fileOrKey) => {
+      const { key } = resolveFile(fileOrKey);
+      return `/api/files/${encodeKeyPath(key)}?${scopeParams}`;
+    },
+    [scopeParams]
+  );
   const deleteFile = useCallback14(
     async (fileOrKey) => {
-      const { key } = resolveFile(fileOrKey);
       try {
         const headers = await authHeaders();
-        const response = await fetch(`/api/files/${encodeKeyPath(key)}?${scopeParams}`, {
+        const response = await fetch(getUrl(fileOrKey), {
           method: "DELETE",
           headers
         });
@@ -3761,32 +3846,40 @@ function useR2Files(options) {
         return { success: false, error: err instanceof Error ? err.message : "Delete failed" };
       }
     },
-    [scopeParams, authHeaders]
+    [getUrl, authHeaders]
   );
-  const list = useCallback14(
-    async (prefix) => {
-      try {
-        const headers = await authHeaders();
-        const params = new URLSearchParams(scopeParams);
-        if (prefix) params.set("prefix", prefix);
-        const response = await fetch(`/api/files?${params.toString()}`, { headers });
-        const result = await response.json();
-        return result.files || [];
-      } catch {
-        return [];
+  const listPage = useCallback14(
+    async (prefix, options2) => {
+      const headers = await authHeaders();
+      const params = new URLSearchParams(scopeParams);
+      if (prefix) params.set("prefix", prefix);
+      if (options2?.limit !== void 0) params.set("limit", String(options2.limit));
+      if (options2?.cursor) params.set("cursor", options2.cursor);
+      const response = await fetch(`/api/files?${params.toString()}`, { headers });
+      if (!response.ok) {
+        throw new Error(describeFilesFailure(response.status, await response.text()));
       }
+      const result = await response.json();
+      return {
+        files: result.files || [],
+        cursor: result.cursor,
+        truncated: result.truncated ?? false
+      };
     },
     [scopeParams, authHeaders]
   );
+  const list = useCallback14(
+    async (prefix, options2) => (await listPage(prefix, options2)).files,
+    [listPage]
+  );
   const downloadFile = useCallback14(
     async (fileOrKey, fileName) => {
       const { key, name: infoName } = resolveFile(fileOrKey);
       try {
         const headers = await authHeaders();
-        const response = await fetch(`/api/files/${encodeKeyPath(key)}?${scopeParams}`, { headers });
+        const response = await fetch(getUrl(key), { headers });
         if (!response.ok) {
-          const body = await response.json().catch(() => null);
-          return { success: false, error: body?.error ?? `Download failed (${response.status})` };
+          return { success: false, error: describeFilesFailure(response.status, await response.text()) };
         }
         const disposition = response.headers.get("Content-Disposition");
         const dispositionName = disposition?.match(/filename="(.+?)"/)?.[1];
@@ -3806,29 +3899,30 @@ function useR2Files(options) {
         return { success: false, error: err instanceof Error ? err.message : "Download failed" };
       }
     },
-    [scopeParams, authHeaders]
+    [getUrl, authHeaders]
   );
   const readFile = useCallback14(
     async (fileOrKey) => {
-      const { key } = resolveFile(fileOrKey);
       const headers = await authHeaders();
-      const response = await fetch(`/api/files/${encodeKeyPath(key)}?${scopeParams}`, { headers });
+      const response = await fetch(getUrl(fileOrKey), { headers });
       if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        throw new Error(`Failed to read file (${response.status}): ${body}`);
+        throw new Error(describeFilesFailure(response.status, await response.text()));
       }
       return response;
     },
-    [scopeParams, authHeaders]
+    [getUrl, authHeaders]
   );
-  const getUrl = useCallback14(
-    (fileOrKey) => {
-      const { key } = resolveFile(fileOrKey);
-      return `/api/files/${encodeKeyPath(key)}?${scopeParams}`;
-    },
-    [scopeParams]
-  );
-  return { upload, uploadBase64, deleteFile, downloadFile, readFile, list, getUrl, isUploading };
+  return {
+    upload,
+    uploadBase64,
+    deleteFile,
+    downloadFile,
+    readFile,
+    list,
+    listPage,
+    getUrl,
+    isUploading
+  };
 }
 
 // src/client/storage/file-attachment-utils.ts
@@ -5164,6 +5258,68 @@ function usePlatformWS(options) {
   return { state, send };
 }
 
+// src/shared/api-error.ts
+var SLUG_RE = /^[a-z0-9]+(?:[_.-][a-z0-9]+)*$/;
+var HUMAN_MESSAGES = {
+  owner_connect_not_ready: "This app isn't ready to accept payments yet \u2014 the app owner needs to finish payment setup.",
+  invalid_json: "The request body was not valid JSON.",
+  invalid_body: "The request body is invalid.",
+  invalid_product_id: "Invalid product id.",
+  duplicate_product_id: "Duplicate product id.",
+  unknown_product: "Unknown product.",
+  too_many_products: "Too many products declared.",
+  invalid_amount: "Invalid amount.",
+  invalid_name: "Invalid product name.",
+  invalid_description: "Invalid product description.",
+  unsupported_currency: "Unsupported currency.",
+  unknown_app: "Unknown app.",
+  not_app_owner: "Only the app owner (or a collaborator) can do this.",
+  invalid_return_url: "Invalid return URL.",
+  invalid_cancel_url: "Invalid cancel URL.",
+  unknown_plan: "Unknown subscription plan.",
+  unknown_price: "No price is configured for that billing interval.",
+  no_subscription: "No subscription found for this account."
+};
+function normalizeApiError(status, body) {
+  const payload = body !== null && typeof body === "object" ? body : {};
+  const rawError = typeof payload.error === "string" ? payload.error : void 0;
+  const message = typeof payload.message === "string" ? payload.message : void 0;
+  const humanError = rawError !== void 0 && !SLUG_RE.test(rawError) ? rawError : void 0;
+  const code = rawError !== void 0 && SLUG_RE.test(rawError) ? rawError : typeof payload.code === "string" && SLUG_RE.test(payload.code) ? payload.code : void 0;
+  const details = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (key === "success" || key === "error" || key === "message" || key === "issues" || key === "code")
+      continue;
+    details[key] = value;
+  }
+  return {
+    error: message ?? humanError ?? (code !== void 0 ? HUMAN_MESSAGES[code] : void 0) ?? rawError ?? `Request failed (${status})`,
+    ...code !== void 0 ? { code } : {},
+    status,
+    ...Object.keys(details).length > 0 ? { details } : {},
+    ...Array.isArray(payload.issues) ? { issues: payload.issues } : {}
+  };
+}
+var PlatformApiError = class extends Error {
+  /** The machine slug (e.g. 'owner_connect_not_ready'), when the server sent one. */
+  code;
+  /** HTTP status of the response; 0 when no HTTP response arrived. */
+  status;
+  /** Structured fields the server sent alongside the error. */
+  details;
+  /** Zod issues accompanying a `validation_failed` response. */
+  issues;
+  constructor(normalized) {
+    super(normalized.error);
+    this.name = "PlatformApiError";
+    this.code = normalized.code;
+    this.status = normalized.status;
+    this.details = normalized.details;
+    this.issues = normalized.issues;
+  }
+};
+var apiErrorCode = (e) => e instanceof PlatformApiError ? e.code ?? null : null;
+
 // src/client/integration.ts
 var ENDPOINT_PREFIX = "/api/integrations";
 var DEFAULT_TIMEOUT_MS2 = 12e4;
@@ -5185,7 +5341,7 @@ async function request(method, endpoint, body, options, query) {
   const url = `${resolveUrl(endpoint)}${queryString ? `?${queryString}` : ""}`;
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   if (options?.signal?.aborted) {
-    return { success: false, error: "Request cancelled" };
+    return { success: false, error: "Request cancelled", status: 0 };
   }
   const headers = {
     "Content-Type": "application/json",
@@ -5215,14 +5371,10 @@ async function request(method, endpoint, body, options, query) {
     try {
       payload = await res.json();
     } catch {
-      return { success: false, error: `Request failed (${res.status})` };
+      return { success: false, error: `Request failed (${res.status})`, status: res.status };
     }
     if (!res.ok || payload.success === false) {
-      return {
-        success: false,
-        error: payload.error ?? payload.message ?? `Request failed (${res.status})`,
-        ...payload.issues ? { issues: payload.issues } : {}
-      };
+      return { success: false, ...normalizeApiError(res.status, payload) };
     }
     if ("data" in payload) {
       return { success: true, data: payload.data };
@@ -5234,12 +5386,14 @@ async function request(method, endpoint, body, options, query) {
     if (err instanceof DOMException && err.name === "AbortError") {
       return {
         success: false,
-        error: timedOut ? `Request timed out after ${timeoutMs}ms` : "Request cancelled"
+        error: timedOut ? `Request timed out after ${timeoutMs}ms` : "Request cancelled",
+        status: 0
       };
     }
     return {
       success: false,
-      error: err instanceof Error ? err.message : "Request failed"
+      error: err instanceof Error ? err.message : "Request failed",
+      status: 0
     };
   } finally {
     clearTimeout(timeout);
@@ -5923,17 +6077,7 @@ function usePagedResource(fetchPage, deps, options = {}) {
 // src/client/subscriptions/useSubscription.ts
 import { useCallback as useCallback27, useEffect as useEffect21, useState as useState18 } from "react";
 
-// src/shared/subscription.ts
-var ENTITLED_STATUSES = /* @__PURE__ */ new Set([
-  "active",
-  "trialing"
-]);
-function isEntitled(tier, status) {
-  if (tier === "free") return true;
-  return ENTITLED_STATUSES.has(status);
-}
-
-// src/client/subscriptions/useSubscription.ts
+// src/client/authed-json.ts
 async function authedJson(path, init) {
   const token = await getAuthToken();
   const res = await fetch(path, {
@@ -5947,10 +6091,22 @@ async function authedJson(path, init) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data.error ?? `Request failed (${res.status})`);
+    throw new PlatformApiError(normalizeApiError(res.status, data));
   }
   return data;
 }
+
+// src/shared/subscription.ts
+var ENTITLED_STATUSES = /* @__PURE__ */ new Set([
+  "active",
+  "trialing"
+]);
+function isEntitled(tier, status) {
+  if (tier === "free") return true;
+  return ENTITLED_STATUSES.has(status);
+}
+
+// src/client/subscriptions/useSubscription.ts
 function useSubscription() {
   const [state, setState] = useState18({
     tier: "free",
@@ -5963,6 +6119,7 @@ function useSubscription() {
   });
   const [isLoading, setLoading] = useState18(true);
   const [error, setError] = useState18(null);
+  const [errorCode, setErrorCode] = useState18(null);
   const refresh = useCallback27(async () => {
     setLoading(true);
     try {
@@ -5977,8 +6134,10 @@ function useSubscription() {
         plans: r.plans ?? []
       });
       setError(null);
+      setErrorCode(null);
     } catch (e) {
       setError(e instanceof Error ? e.message : "Failed to load subscription");
+      setErrorCode(apiErrorCode(e));
     } finally {
       setLoading(false);
     }
@@ -6040,6 +6199,7 @@ function useSubscription() {
     trialEndsAt: state.trialEndsAt,
     isLoading,
     error,
+    errorCode,
     hasTier,
     isAtLeast,
     plans: state.plans,
@@ -6091,37 +6251,23 @@ function PricingTable(props) {
 
 // src/client/charges/useCheckout.ts
 import { useCallback as useCallback28, useEffect as useEffect22, useMemo as useMemo17, useState as useState19 } from "react";
-async function authedJson2(path, init) {
-  const token = await getAuthToken();
-  const res = await fetch(path, {
-    ...init,
-    credentials: "include",
-    headers: {
-      "Content-Type": "application/json",
-      ...token ? { Authorization: `Bearer ${token}` } : {},
-      ...init?.headers
-    }
-  });
-  const data = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    throw new Error(data.error ?? `Request failed (${res.status})`);
-  }
-  return data;
-}
 function useCheckout(opts) {
   const [purchases, setPurchases] = useState19([]);
   const [isLoading, setLoading] = useState19(true);
   const [error, setError] = useState19(null);
+  const [errorCode, setErrorCode] = useState19(null);
   const refresh = useCallback28(async () => {
     setLoading(true);
     try {
-      const r = await authedJson2(
+      const r = await authedJson(
         "/_deepspace/charges/me"
       );
       setPurchases(r.purchases ?? []);
       setError(null);
+      setErrorCode(null);
     } catch (e) {
       setError(e instanceof Error ? e.message : "Failed to load purchases");
+      setErrorCode(apiErrorCode(e));
     } finally {
       setLoading(false);
     }
@@ -6132,6 +6278,7 @@ function useCheckout(opts) {
   const chargeOnce = useCallback28(
     async (chargeOpts) => {
       setError(null);
+      setErrorCode(null);
       const common = {
         returnUrl: chargeOpts.returnUrl ?? window.location.href,
         cancelUrl: chargeOpts.cancelUrl ?? window.location.href,
@@ -6144,7 +6291,7 @@ function useCheckout(opts) {
         ...chargeOpts.description ? { description: chargeOpts.description } : {}
       };
       try {
-        const result = await authedJson2(
+        const result = await authedJson(
           "/_deepspace/charges/create",
           {
             method: "POST",
@@ -6158,6 +6305,7 @@ function useCheckout(opts) {
       } catch (e) {
         const msg = e instanceof Error ? e.message : "Failed to start checkout";
         setError(msg);
+        setErrorCode(apiErrorCode(e));
         throw e;
       }
     },
@@ -6175,6 +6323,7 @@ function useCheckout(opts) {
     chargeOnce,
     isLoading,
     error,
+    errorCode,
     purchases,
     owned,
     ownsProduct,
@@ -6351,6 +6500,7 @@ export {
   MSG_SYNC_UPDATE,
   MSG_YJS_AWARENESS,
   MSG_YJS_SYNC,
+  PlatformApiError,
   PlatformContext,
   PlatformProvider,
   PricingTable,