@cueframe/kernel 0.0.1 → 0.1.0

package/dist/_members/account-model/testing/conversationStoreContract.d.ts

@@ -2,7 +2,7 @@
  * THE CONVERSATION STORE CONTRACT — one executable statement, every store.
  *
  * A Director thread is persisted by TWO independent implementations: the
- * desktop's sqlite (`cueframe/src-tauri/src/database/conversations.rs`) and the
+ * desktop's sqlite (`apps/studio/src-tauri/src/database/conversations.rs`) and the
  * org's Convex documents (`the backend conversation store`), reached through
  * an adapter each (`platform/tauri.ts`, `packages/web/adapter.ts`). A third
  * "implementation" exists in the test double the app's own tests run against.

package/dist/_members/authoring/providers/resourceApi.d.ts

@@ -2,7 +2,7 @@ import type { FontResult, LottieResult } from '../types.js';
 /**
  * Public-API resource clients — pure HTTP, no gateway auth.
  *
- * Lifted from `cueframe/src/llm/resourceApi.ts` so both the desktop Tauri
+ * Lifted from `apps/studio/src/llm/resourceApi.ts` so both the desktop Tauri
  * app and the server-side Temporal director worker can call the same
  * Google Fonts + LottieFiles clients. Gateway-routed search (Pexels,
  * Pixabay, Freesound, Klipy) lives in `../resources.ts` — that module

package/dist/_members/authoring/transpileComponent.d.ts

@@ -11,7 +11,7 @@
  * remotion / animate as endowments — and (b) assign `exports.default = <Component>`.
  *
  * This is the Node/native-esbuild sibling of the desktop `transpileJsx`
- * (cueframe/src/llm/transpile.ts, esbuild-wasm) and the director's
+ * (apps/studio/src/llm/transpile.ts, esbuild-wasm) and the director's
  * `serverTranspiler` (activities/director.ts). All three share ONE transpile
  * config — the SSOT `ESBUILD_JSX_OPTIONS` + `postProcessForSandbox` in
  * ./transpileHelper — so a live component transpiled here is byte-identical to

package/dist/_members/cloud-import/CloudImportService.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Singleton Uppy service for imports (local + cloud).
+ *
+ * Uses @uppy/aws-s3 for multipart uploads directly to R2 via the
+ * upload-signing CF Worker. Replaces the old TUS-based upload path.
+ *
+ * Owns the Uppy instance lifecycle (headless — no Dashboard plugin).
+ * React integration is handled by ImportProvider (single mount at app root).
+ * MediaItem pre-creation is handled by MediaItemPreprocessor (Uppy plugin).
+ */
+import Uppy from '@uppy/core';
+import { MediaItemPreprocessor } from './MediaItemPreprocessor.js';
+interface CloudImportConfig {
+    uploadSigningUrl: string;
+}
+export interface CloudUploadResult {
+    uploadURL: string;
+    fileName: string;
+    fileSize: number;
+}
+declare class CloudImportService {
+    private uppy;
+    private config;
+    /** Lazy-init: create Uppy + plugins on first use. */
+    init(config: CloudImportConfig): Uppy;
+    /** Get the Uppy instance (must call init() first). */
+    getUppy(): Uppy;
+    /** Get the MediaItemPreprocessor plugin. */
+    getPreprocessor(): MediaItemPreprocessor;
+    /** Update upload metadata (uploadToken, userId, projectId). */
+    setMeta(meta: Record<string, string>): void;
+}
+/** Module-level singleton. */
+export declare const cloudImportService: CloudImportService;
+export {};

package/dist/_members/cloud-import/ImportProvider.d.ts

@@ -0,0 +1,73 @@
+/**
+ * ImportProvider — single mount at app root.
+ *
+ * Initializes the CloudImportService, wires auth callbacks, and provides
+ * the useImport() hook to child components. Wraps children in Uppy's
+ * UppyContextProvider so headless hooks (useDropzone, useUppyState, etc.)
+ * work anywhere in the tree.
+ *
+ * The import dialog UI is injected via `dialogSlot` to avoid circular
+ * dependency between @cueframe/cloud-import and @cueframe/pro.
+ */
+import { type ReactNode } from 'react';
+import type Uppy from '@uppy/core';
+import type { CloudUploadResult } from './CloudImportService.js';
+interface ImportContextValue {
+    openModal: () => void;
+    closeModal: () => void;
+    isOpen: boolean;
+    uppy: Uppy;
+    /**
+     * Can this lane actually take an upload right now?
+     *
+     * A cloud import needs an identity: `getUploadMeta` mints an org-scoped
+     * upload token, so with none the modal opens onto a request that can only
+     * fail. This is DATA because the provider is now a fixture of the tree — it
+     * mounts for the life of the desktop process, signed in or not, so its
+     * PRESENCE stopped being the answer to this question (it was, back when the
+     * whole cloud stack mounted only inside a confirmed auth handshake).
+     */
+    available: boolean;
+}
+export interface ImportProviderProps {
+    children: ReactNode;
+    /** Whether this lane can take an upload — see `ImportContextValue.available`.
+     *  Required, with no default: the one thing a caller must not forget is the
+     *  fact that decides whether a control is offered at all. */
+    available: boolean;
+    /** React element to render the import dialog (e.g. <ImportDialog />) */
+    dialogSlot?: ReactNode;
+    uploadSigningUrl: string;
+    /** Called before opening the modal — returns upload metadata (token, userId, etc). */
+    getUploadMeta?: () => Promise<Record<string, string>>;
+    /** Pre-create a mediaItem — called by the preprocessor plugin before upload starts. */
+    createMediaItem?: (file: {
+        name: string;
+        size: number;
+        mimeType: string;
+    }) => Promise<string>;
+    onUploadComplete?: (results: CloudUploadResult[]) => void;
+    onError?: (error: Error) => void;
+}
+export declare function ImportProvider({ children, available, dialogSlot, uploadSigningUrl, getUploadMeta, createMediaItem, onUploadComplete, onError, }: ImportProviderProps): import("react").JSX.Element;
+/** Hook to access the import modal and Uppy instance. Must be used inside <ImportProvider>. */
+export declare function useImport(): ImportContextValue;
+/**
+ * The context WHEN THE LANE CAN BE USED, and `null` otherwise — for surfaces
+ * that offer the cloud modal only where it works and fall back where it does
+ * not (the pro ImportButton, which drops to the local file picker).
+ *
+ * It used to answer presence alone, and presence used to be the same fact:
+ * the provider mounted only inside a confirmed auth handshake. It mounts for
+ * the life of the desktop process now (Task 11 — a provider that appears and
+ * disappears re-parents the app), so presence would offer a cloud modal to a
+ * signed-out user whose upload-token request can only fail: a control that
+ * looks alive and silently does nothing.
+ *
+ * Still ONE fact, read from the tree rather than mirrored: the alternative —
+ * a caller re-deriving `isDesktop && cloudEnabled && signedIn` — is the drift
+ * class that crashed the desktop ("useImport must be used within
+ * <ImportProvider>") whenever the two copies disagreed.
+ */
+export declare function useImportIfAvailable(): ImportContextValue | null;
+export {};

package/dist/_members/cloud-import/MediaItemPreprocessor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Uppy preprocessor plugin that pre-creates a mediaItem in the backend
+ * before the upload starts. This guarantees convexMediaItemId is in the
+ * upload metadata before the first byte goes out — no race condition.
+ *
+ * The actual creation function is injected via setCreateFn() so the plugin
+ * stays decoupled from Convex/auth concerns.
+ */
+import { BasePlugin } from '@uppy/core';
+import type { Uppy, Meta } from '@uppy/core';
+type CreateMediaItemFn = (file: {
+    name: string;
+    size: number;
+    mimeType: string;
+}) => Promise<string>;
+export declare class MediaItemPreprocessor extends BasePlugin<Record<string, never>, Meta, Record<string, never>> {
+    static pluginId: string;
+    private createFn;
+    private preprocessBound;
+    constructor(uppy: Uppy, opts?: Record<string, never>);
+    /** Inject the creation function (called from ImportProvider). */
+    setCreateFn(fn: CreateMediaItemFn | null): void;
+    install(): void;
+    uninstall(): void;
+    private preprocess;
+}
+export {};

package/dist/_members/cloud-import/chunk-XKO6ZSWI.js

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../data-models/media-model/src/media-kind.ts
+var IMAGE_CONTENT_TYPES = ["image/png", "image/jpeg", "image/webp"];
+var ALLOWED_CONTENT_TYPES = [
+  "video/mp4",
+  "video/quicktime",
+  "video/x-matroska",
+  "video/webm",
+  "audio/mpeg",
+  "audio/wav",
+  "audio/x-wav",
+  "audio/mp4",
+  "audio/aac",
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif",
+  "image/svg+xml",
+  "application/json",
+  "font/ttf",
+  "font/otf",
+  "font/woff",
+  "font/woff2"
+];
+function mediaKind(contentType) {
+  const ct = (contentType || "").toLowerCase();
+  if (ct.startsWith("video/")) return "video";
+  if (ct.startsWith("audio/")) return "audio";
+  if (IMAGE_CONTENT_TYPES.includes(ct)) return "image";
+  return "opaque";
+}
+var EXT = {
+  "video/mp4": "mp4",
+  "audio/mp4": "mp4",
+  "video/quicktime": "mov",
+  "video/x-matroska": "mkv",
+  "video/webm": "webm",
+  "video/x-msvideo": "avi",
+  "audio/mpeg": "mp3",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/aac": "aac",
+  "audio/ogg": "ogg",
+  "audio/flac": "flac",
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "font/ttf": "ttf",
+  "font/otf": "otf",
+  "font/woff": "woff",
+  "font/woff2": "woff2",
+  "application/json": "json",
+  "image/svg+xml": "svg",
+  "image/gif": "gif"
+};
+var CONTENT_TYPE_ALIASES = {
+  "audio/mp3": "audio/mpeg",
+  "audio/x-mp3": "audio/mpeg",
+  "audio/x-mpeg": "audio/mpeg",
+  "audio/mpeg3": "audio/mpeg",
+  "audio/x-mpeg-3": "audio/mpeg",
+  "audio/x-m4a": "audio/mp4",
+  "audio/m4a": "audio/mp4",
+  "audio/wave": "audio/wav",
+  "audio/vnd.wave": "audio/wav",
+  "audio/x-aac": "audio/aac",
+  "image/jpg": "image/jpeg",
+  "video/x-quicktime": "video/quicktime",
+  "video/mov": "video/quicktime",
+  "video/x-m4v": "video/mp4",
+  "video/mkv": "video/x-matroska"
+};
+var TYPE_BY_EXTENSION = Object.entries(EXT).reduce(
+  (acc, [contentType, ext]) => {
+    if (!(ext in acc)) acc[ext] = contentType;
+    return acc;
+  },
+  {}
+);
+TYPE_BY_EXTENSION["jpeg"] = "image/jpeg";
+TYPE_BY_EXTENSION["m4a"] = "audio/mp4";
+var POOL_EXTENSIONS = Object.entries(TYPE_BY_EXTENSION).filter(([, contentType]) => mediaKind(contentType) !== "opaque").map(([ext]) => ext);
+function contentTypeForUpload(filename, claimed) {
+  const ct = (claimed ?? "").trim().toLowerCase();
+  const allowed = ALLOWED_CONTENT_TYPES;
+  if (ct && allowed.includes(ct)) return ct;
+  if (ct && CONTENT_TYPE_ALIASES[ct]) return CONTENT_TYPE_ALIASES[ct];
+  const ext = filename.toLowerCase().split(".").pop() ?? "";
+  const byExt = TYPE_BY_EXTENSION[ext];
+  if (byExt) return byExt;
+  return ct;
+}
+
+// src/multipartUpload.ts
+var CHUNK_SIZE = 10 * 1024 * 1024;
+async function reasonFrom(res) {
+  try {
+    const text = await res.text();
+    if (!text) return `HTTP ${res.status}`;
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed.error === "string" && parsed.error) return `${parsed.error} (HTTP ${res.status})`;
+    } catch {
+    }
+    return `${text.slice(0, 200)} (HTTP ${res.status})`;
+  } catch {
+    return `HTTP ${res.status}`;
+  }
+}
+async function multipartUpload(opts) {
+  const { file, signingUrl, token, metadata, onProgress } = opts;
+  const baseUrl = signingUrl.replace(/\/$/, "");
+  const headers = { "uppy-auth-token": token, "Content-Type": "application/json" };
+  const createRes = await fetch(`${baseUrl}/s3/multipart`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      filename: file.name,
+      // NOT `file.type || "video/mp4"`. That fallback relabelled every untyped
+      // file as video, so an MP3 with no MIME uploaded as `video/mp4` and was
+      // routed down the video transcode path by `mediaKind()` — a wrong
+      // pipeline instead of an honest refusal. See `contentTypeForUpload`.
+      type: contentTypeForUpload(file.name, file.type),
+      metadata: { uploadToken: token, ...metadata }
+    })
+  });
+  if (!createRes.ok) throw new Error(`Upload init failed for ${file.name}: ${await reasonFrom(createRes)}`);
+  const { uploadId } = await createRes.json();
+  const totalParts = Math.ceil(file.size / CHUNK_SIZE);
+  const parts = [];
+  for (let i = 0; i < totalParts; i++) {
+    const start = i * CHUNK_SIZE;
+    const end = Math.min(start + CHUNK_SIZE, file.size);
+    const chunk = file.slice(start, end);
+    const partNumber = i + 1;
+    const urlRes = await fetch(`${baseUrl}/s3/multipart/${uploadId}/${partNumber}`, {
+      headers: { "uppy-auth-token": token }
+    });
+    if (!urlRes.ok) throw new Error(`Presign failed for ${file.name} part ${partNumber}: ${await reasonFrom(urlRes)}`);
+    const { url } = await urlRes.json();
+    const putRes = await fetch(url, { method: "PUT", body: chunk });
+    if (!putRes.ok) throw new Error(`Part ${partNumber} of ${file.name} failed: ${await reasonFrom(putRes)}`);
+    parts.push({ PartNumber: partNumber, ETag: putRes.headers.get("ETag") ?? "" });
+    onProgress?.(end / file.size);
+  }
+  const completeRes = await fetch(`${baseUrl}/s3/multipart/${uploadId}/complete`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ parts })
+  });
+  if (!completeRes.ok) throw new Error(`Complete failed for ${file.name}: ${await reasonFrom(completeRes)}`);
+  return await completeRes.json();
+}
+
+export {
+  __publicField,
+  multipartUpload
+};
+//# sourceMappingURL=chunk-XKO6ZSWI.js.map

package/dist/_members/cloud-import/chunk-XKO6ZSWI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../data-models/media-model/src/media-kind.ts","../src/multipartUpload.ts"],"sourcesContent":["/** `opaque` is `asset` renamed (spec §5): \"asset\" was the word that made two\n *  different concepts — storage furniture and a media classification — look\n *  like one. `opaque` states the contract: no pipeline, not placeable. */\nexport type MediaKind = \"video\" | \"audio\" | \"image\" | \"opaque\";\n\nexport const IMAGE_CONTENT_TYPES = [\"image/png\", \"image/jpeg\", \"image/webp\"] as const;\n\n/** Closed allowlist — the complete set of accepted content-types (the acceptance\n *  gate). mediaKind() routes each: video/audio/still-image do real work;\n *  fonts/json/svg/gif route to the opaque path. Unknown bytes (not here)\n *  are rejected at the edge. */\nexport const ALLOWED_CONTENT_TYPES = [\n  \"video/mp4\", \"video/quicktime\", \"video/x-matroska\", \"video/webm\",\n  \"audio/mpeg\", \"audio/wav\", \"audio/x-wav\", \"audio/mp4\", \"audio/aac\",\n  \"image/png\", \"image/jpeg\", \"image/webp\",\n  \"image/gif\", \"image/svg+xml\", \"application/json\",\n  \"font/ttf\", \"font/otf\", \"font/woff\", \"font/woff2\",\n] as const;\n\nexport type AllowedContentType = (typeof ALLOWED_CONTENT_TYPES)[number];\n\nexport function mediaKind(contentType: string): MediaKind {\n  const ct = (contentType || \"\").toLowerCase();\n  if (ct.startsWith(\"video/\")) return \"video\";\n  if (ct.startsWith(\"audio/\")) return \"audio\";\n  if ((IMAGE_CONTENT_TYPES as readonly string[]).includes(ct)) return \"image\";\n  return \"opaque\";\n}\n\nconst EXT: Record<string, string> = {\n  \"video/mp4\": \"mp4\", \"audio/mp4\": \"mp4\", \"video/quicktime\": \"mov\",\n  \"video/x-matroska\": \"mkv\", \"video/webm\": \"webm\", \"video/x-msvideo\": \"avi\",\n  \"audio/mpeg\": \"mp3\", \"audio/wav\": \"wav\", \"audio/x-wav\": \"wav\", \"audio/aac\": \"aac\",\n  \"audio/ogg\": \"ogg\", \"audio/flac\": \"flac\",\n  \"image/png\": \"png\", \"image/jpeg\": \"jpg\", \"image/webp\": \"webp\",\n  \"font/ttf\": \"ttf\", \"font/otf\": \"otf\", \"font/woff\": \"woff\", \"font/woff2\": \"woff2\",\n  \"application/json\": \"json\", \"image/svg+xml\": \"svg\", \"image/gif\": \"gif\",\n};\nexport function extensionForContentType(contentType: string): string {\n  return EXT[(contentType || \"\").toLowerCase()] ?? \"bin\";\n}\n\n/**\n * MIME ALIASES THE PLATFORM EMITS FOR TYPES WE ALREADY ACCEPT.\n *\n * `ALLOWED_CONTENT_TYPES` is a CLOSED gate keyed on an exact string, and the\n * same bytes get different strings depending on who describes them: WebKit says\n * `audio/mp3` where the registry says `audio/mpeg`, Apple says `audio/x-m4a`\n * where the registry says `audio/mp4`. Rejecting those is not the gate doing\n * its job — it is the gate mistaking a spelling for a format, and the user gets\n * \"Unsupported file type\" for a plain MP3.\n *\n * Only aliases of types ALREADY on the allowlist belong here. This must not\n * become a way to smuggle in a format the pipeline cannot decode.\n */\nconst CONTENT_TYPE_ALIASES: Record<string, string> = {\n  \"audio/mp3\": \"audio/mpeg\",\n  \"audio/x-mp3\": \"audio/mpeg\",\n  \"audio/x-mpeg\": \"audio/mpeg\",\n  \"audio/mpeg3\": \"audio/mpeg\",\n  \"audio/x-mpeg-3\": \"audio/mpeg\",\n  \"audio/x-m4a\": \"audio/mp4\",\n  \"audio/m4a\": \"audio/mp4\",\n  \"audio/wave\": \"audio/wav\",\n  \"audio/vnd.wave\": \"audio/wav\",\n  \"audio/x-aac\": \"audio/aac\",\n  \"image/jpg\": \"image/jpeg\",\n  \"video/x-quicktime\": \"video/quicktime\",\n  \"video/mov\": \"video/quicktime\",\n  \"video/x-m4v\": \"video/mp4\",\n  \"video/mkv\": \"video/x-matroska\",\n};\n\n/** Extension → canonical content-type, derived from the EXT map so the two\n *  cannot drift. Built once. */\nconst TYPE_BY_EXTENSION: Record<string, string> = Object.entries(EXT).reduce<Record<string, string>>(\n  (acc, [contentType, ext]) => {\n    // First writer wins, so `audio/mp4` does not steal `mp4` from `video/mp4`.\n    if (!(ext in acc)) acc[ext] = contentType;\n    return acc;\n  },\n  {},\n);\n// Spellings EXT cannot carry (it is contentType→ext, one ext per type): the\n// long form of jpg, and m4a — whose canonical type audio/mp4 lost the \"mp4\"\n// slot to video above.\nTYPE_BY_EXTENSION[\"jpeg\"] = \"image/jpeg\";\nTYPE_BY_EXTENSION[\"m4a\"] = \"audio/mp4\";\n\n/** What a file IS, from nothing but its name — the ONE derivation the import\n *  door, the project-file parse gate, and migration 020's SQL all mirror. */\nexport function mediaKindForFilename(filename: string): MediaKind {\n  return mediaKind(contentTypeForUpload(filename, null));\n}\n\n/** Every extension whose derived kind can occupy time. The import door's\n *  accept-list IS this list — derived, so the door and the authority cannot\n *  disagree (the disagreement was a thrown import for `.jpeg`/`.m4a`). */\nexport const POOL_EXTENSIONS: readonly string[] = Object.entries(TYPE_BY_EXTENSION)\n  .filter(([, contentType]) => mediaKind(contentType) !== \"opaque\")\n  .map(([ext]) => ext);\n\n/**\n * The content-type to UPLOAD a file as, given what the platform claimed and\n * what the file is called.\n *\n * WHY THIS EXISTS. The upload client used to send `file.type || \"video/mp4\"`.\n * Both halves are wrong: the alias case rejects real MP3s (see above), and the\n * fallback silently relabels ANY untyped file as video — so an MP3 dragged in\n * without a MIME is accepted and then routed down the VIDEO transcode path by\n * `mediaKind()`, which is a wrong pipeline rather than an honest refusal.\n *\n * Order: an already-allowed type wins, then a known alias, then the extension.\n * If none of those resolve, the ORIGINAL string is returned unchanged — never a\n * guess. The closed gate then refuses it and names the type the user actually\n * has, which is the error message they need.\n */\nexport function contentTypeForUpload(filename: string, claimed?: string | null): string {\n  const ct = (claimed ?? \"\").trim().toLowerCase();\n  const allowed = ALLOWED_CONTENT_TYPES as readonly string[];\n\n  if (ct && allowed.includes(ct)) return ct;\n  if (ct && CONTENT_TYPE_ALIASES[ct]) return CONTENT_TYPE_ALIASES[ct];\n\n  const ext = filename.toLowerCase().split(\".\").pop() ?? \"\";\n  const byExt = TYPE_BY_EXTENSION[ext];\n  if (byExt) return byExt;\n\n  return ct;\n}\n","/**\n * S3 multipart upload via the upload-signing CF Worker.\n * Shared by FileUpload component and adapter.ts.\n *\n * EVERY FAILURE HERE CARRIES THE SERVER'S REASON. These throws used to be\n * `Upload init failed: ${status}` — status only. The worker answers a rejected\n * create with `{\"error\":\"Unsupported file type: audio/mp3\"}`, i.e. it says\n * exactly what is wrong and which type it saw, and the client discarded it. A\n * user then sees \"failed\" with no cause, and neither the app log nor any\n * server-side log has the string either (this module has no logger and the\n * worker returns 400 rather than throwing). On 2026-08-18 that cost a long\n * diagnosis of a single stuck MP3. `reasonFrom` puts the body back.\n */\n// SUBPATH, NOT THE BARREL. `@cueframe/media-model`'s root re-exports `./api`,\n// which pulls zod and the Convex validators — none of which this BROWSER bundle\n// needs. The `./media-kind` entry is the pure classifier, zero imports; take it\n// alone. (Until 2026-08-25 this classifier lived in `@cueframe/shared`, whose\n// barrel dragged `@sentry/node-core` in and broke the build on `\"subscribe\" is\n// not exported by \"__vite-browser-external\"` — a sharper version of the same\n// rule. It moved so no public package reaches into the private `shared`.)\nimport { contentTypeForUpload } from \"@cueframe/media-model/media-kind\";\n\nconst CHUNK_SIZE = 10 * 1024 * 1024; // 10MB parts\n\n/**\n * The server's own words, when it has any. The worker replies with\n * `{error: string}`; anything else (an HTML error page, an empty body) falls\n * back to the status, which is still better than nothing.\n */\nasync function reasonFrom(res: Response): Promise<string> {\n  try {\n    const text = await res.text();\n    if (!text) return `HTTP ${res.status}`;\n    try {\n      const parsed = JSON.parse(text) as { error?: unknown };\n      if (typeof parsed.error === \"string\" && parsed.error) return `${parsed.error} (HTTP ${res.status})`;\n    } catch {\n      // Not JSON — fall through to the raw text.\n    }\n    return `${text.slice(0, 200)} (HTTP ${res.status})`;\n  } catch {\n    return `HTTP ${res.status}`;\n  }\n}\n\nexport interface MultipartUploadOptions {\n  file: File;\n  signingUrl: string;\n  token: string;\n  metadata?: Record<string, string>;\n  onProgress?: (fraction: number) => void;\n}\n\nexport interface MultipartUploadResult {\n  location: string;\n  mediaItemId: string;\n}\n\nexport async function multipartUpload(opts: MultipartUploadOptions): Promise<MultipartUploadResult> {\n  const { file, signingUrl, token, metadata, onProgress } = opts;\n  const baseUrl = signingUrl.replace(/\\/$/, \"\");\n  const headers = { \"uppy-auth-token\": token, \"Content-Type\": \"application/json\" };\n\n  // 1. Create multipart upload\n  const createRes = await fetch(`${baseUrl}/s3/multipart`, {\n    method: \"POST\",\n    headers,\n    body: JSON.stringify({\n      filename: file.name,\n      // NOT `file.type || \"video/mp4\"`. That fallback relabelled every untyped\n      // file as video, so an MP3 with no MIME uploaded as `video/mp4` and was\n      // routed down the video transcode path by `mediaKind()` — a wrong\n      // pipeline instead of an honest refusal. See `contentTypeForUpload`.\n      type: contentTypeForUpload(file.name, file.type),\n      metadata: { uploadToken: token, ...metadata },\n    }),\n  });\n  if (!createRes.ok) throw new Error(`Upload init failed for ${file.name}: ${await reasonFrom(createRes)}`);\n  const { uploadId } = (await createRes.json()) as { uploadId: string; key: string };\n\n  // 2. Upload parts sequentially\n  const totalParts = Math.ceil(file.size / CHUNK_SIZE);\n  const parts: Array<{ PartNumber: number; ETag: string }> = [];\n\n  for (let i = 0; i < totalParts; i++) {\n    const start = i * CHUNK_SIZE;\n    const end = Math.min(start + CHUNK_SIZE, file.size);\n    const chunk = file.slice(start, end);\n    const partNumber = i + 1;\n\n    // Get presigned URL\n    const urlRes = await fetch(`${baseUrl}/s3/multipart/${uploadId}/${partNumber}`, {\n      headers: { \"uppy-auth-token\": token },\n    });\n    if (!urlRes.ok) throw new Error(`Presign failed for ${file.name} part ${partNumber}: ${await reasonFrom(urlRes)}`);\n    const { url } = (await urlRes.json()) as { url: string };\n\n    // PUT to presigned URL\n    const putRes = await fetch(url, { method: \"PUT\", body: chunk });\n    if (!putRes.ok) throw new Error(`Part ${partNumber} of ${file.name} failed: ${await reasonFrom(putRes)}`);\n    parts.push({ PartNumber: partNumber, ETag: putRes.headers.get(\"ETag\") ?? \"\" });\n\n    onProgress?.(end / file.size);\n  }\n\n  // 3. Complete multipart upload\n  const completeRes = await fetch(`${baseUrl}/s3/multipart/${uploadId}/complete`, {\n    method: \"POST\",\n    headers,\n    body: JSON.stringify({ parts }),\n  });\n  if (!completeRes.ok) throw new Error(`Complete failed for ${file.name}: ${await reasonFrom(completeRes)}`);\n\n  return (await completeRes.json()) as MultipartUploadResult;\n}\n"],"mappings":"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","names":[]}

package/dist/_members/cloud-import/cloudConfig.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Single source of truth for cloud endpoint resolution.
+ *
+ * One input (convexUrl) → deterministic output (all cloud endpoints).
+ * No fallback chains, no env var reading, no defaults.
+ */
+export type CloudEnvironment = 'dev' | 'staging' | 'production';
+export interface CloudEndpoints {
+    convexUrl: string;
+    uploadSigningUrl: string;
+}
+export declare const ENVIRONMENTS: Record<CloudEnvironment, CloudEndpoints>;
+/** Detect environment from a Convex deployment URL.
+ *
+ * Convex exposes two domains per deployment: queries (`data*`) and HTTP
+ * actions (`api*`). Callers pass either form depending on which client
+ * they own, so detection has to recognize both:
+ *   prod    → api.cueframe.ai     | data.cueframe.ai
+ *   staging → api-dev.cueframe.ai | data-dev.cueframe.ai
+ */
+export declare function detectEnvironment(convexUrl?: string): CloudEnvironment;
+/** Resolve all cloud endpoints from a Convex URL. */
+export declare function getEndpoints(convexUrl: string): CloudEndpoints;

package/dist/_members/cloud-import/index.d.ts

@@ -0,0 +1,9 @@
+export { ImportProvider, useImport, useImportIfAvailable } from './ImportProvider.js';
+export type { ImportProviderProps } from './ImportProvider.js';
+export { cloudImportService } from './CloudImportService.js';
+export type { CloudUploadResult } from './CloudImportService.js';
+export { ENVIRONMENTS, detectEnvironment, getEndpoints } from './cloudConfig.js';
+export type { CloudEnvironment, CloudEndpoints } from './cloudConfig.js';
+export { multipartUpload } from './multipartUpload.js';
+export type { MultipartUploadOptions, MultipartUploadResult } from './multipartUpload.js';
+export { useDropzone, useUppyState, useUppyEvent, } from '@uppy/react';

package/dist/_members/cloud-import/index.js

@@ -0,0 +1,241 @@
+import {
+  __publicField,
+  multipartUpload
+} from "./chunk-XKO6ZSWI.js";
+
+// src/ImportProvider.tsx
+import { createContext, useContext, useState, useEffect, useCallback, useRef } from "react";
+import { UppyContextProvider } from "@uppy/react";
+
+// src/CloudImportService.ts
+import Uppy from "@uppy/core";
+import AwsS3 from "@uppy/aws-s3";
+
+// src/MediaItemPreprocessor.ts
+import { BasePlugin } from "@uppy/core";
+var _MediaItemPreprocessor = class _MediaItemPreprocessor extends BasePlugin {
+  constructor(uppy, opts) {
+    super(uppy, opts ?? {});
+    __publicField(this, "createFn", null);
+    __publicField(this, "preprocessBound");
+    this.id = _MediaItemPreprocessor.pluginId;
+    this.type = "preprocessor";
+    this.preprocessBound = this.preprocess.bind(this);
+  }
+  /** Inject the creation function (called from ImportProvider). */
+  setCreateFn(fn) {
+    this.createFn = fn;
+  }
+  install() {
+    this.uppy.addPreProcessor(this.preprocessBound);
+  }
+  uninstall() {
+    this.uppy.removePreProcessor(this.preprocessBound);
+  }
+  async preprocess(fileIDs) {
+    if (!this.createFn) return;
+    for (const fileID of fileIDs) {
+      const file = this.uppy.getFile(fileID);
+      if (!file) continue;
+      if (file.meta.convexMediaItemId) continue;
+      this.uppy.emit("preprocess-progress", file, {
+        mode: "indeterminate",
+        message: "Preparing upload\u2026"
+      });
+      try {
+        const mediaItemId = await this.createFn({
+          name: file.name ?? "unknown",
+          size: file.size ?? 0,
+          mimeType: file.type ?? "video/mp4"
+        });
+        this.uppy.setFileMeta(fileID, { convexMediaItemId: mediaItemId });
+      } catch (err) {
+        this.uppy.log(`[MediaItemPreprocessor] Failed for ${fileID}: ${err}`, "error");
+      }
+      this.uppy.emit("preprocess-complete", file);
+    }
+  }
+};
+__publicField(_MediaItemPreprocessor, "pluginId", "MediaItemPreprocessor");
+var MediaItemPreprocessor = _MediaItemPreprocessor;
+
+// src/CloudImportService.ts
+var CloudImportService = class {
+  constructor() {
+    __publicField(this, "uppy", null);
+    __publicField(this, "config", null);
+  }
+  /** Lazy-init: create Uppy + plugins on first use. */
+  init(config) {
+    if (this.uppy) return this.uppy;
+    this.config = config;
+    const signingUrl = this.config.uploadSigningUrl.replace(/\/$/, "");
+    this.uppy = new Uppy({
+      id: "cloud-import",
+      restrictions: {
+        allowedFileTypes: ["video/*", "audio/*"]
+      }
+    }).use(AwsS3, {
+      // Upload-signing Worker implements the S3 multipart endpoints at /s3/multipart/*
+      endpoint: signingUrl,
+      shouldUseMultipart: true,
+      // Cap concurrent multipart part uploads. Unbounded concurrency
+      // saturates the browser network stack and the signing Worker on
+      // large files; 3 keeps throughput high without melting either.
+      limit: 3,
+      // Exponential-ish backoff for failed part/signing requests. Uppy
+      // retries the same operation on each delay — keeps transient
+      // network blips from failing an entire upload.
+      retryDelays: [1e3, 3e3, 5e3, 1e4]
+    }).use(MediaItemPreprocessor);
+    return this.uppy;
+  }
+  /** Get the Uppy instance (must call init() first). */
+  getUppy() {
+    if (!this.uppy) throw new Error("CloudImportService not initialized \u2014 call init() first");
+    return this.uppy;
+  }
+  /** Get the MediaItemPreprocessor plugin. */
+  getPreprocessor() {
+    return this.getUppy().getPlugin(MediaItemPreprocessor.pluginId);
+  }
+  /** Update upload metadata (uploadToken, userId, projectId). */
+  setMeta(meta) {
+    this.uppy?.setMeta(meta);
+    if (meta.uploadToken) {
+      const plugin = this.uppy?.getPlugin("AwsS3Multipart");
+      if (plugin) {
+        plugin.setOptions({ headers: { "uppy-auth-token": meta.uploadToken } });
+      }
+    }
+  }
+};
+var cloudImportService = new CloudImportService();
+
+// src/ImportProvider.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var ImportContext = createContext(null);
+function ImportProvider({
+  children,
+  available,
+  dialogSlot,
+  uploadSigningUrl,
+  getUploadMeta,
+  createMediaItem,
+  onUploadComplete,
+  onError
+}) {
+  const [isOpen, setIsOpen] = useState(false);
+  const onCompleteRef = useRef(onUploadComplete);
+  const onErrorRef = useRef(onError);
+  onCompleteRef.current = onUploadComplete;
+  onErrorRef.current = onError;
+  const [uppy] = useState(() => cloudImportService.init({ uploadSigningUrl }));
+  useEffect(() => {
+    const handleComplete = (result) => {
+      const successful = result?.successful ?? [];
+      if (successful.length > 0 && onCompleteRef.current) {
+        onCompleteRef.current(
+          successful.map((file) => ({
+            uploadURL: file.response?.uploadURL ?? "",
+            fileName: file.name ?? "unknown",
+            fileSize: file.size ?? 0
+          }))
+        );
+      }
+    };
+    const handleError = (error) => {
+      onErrorRef.current?.(error instanceof Error ? error : new Error(String(error)));
+    };
+    uppy.on("complete", handleComplete);
+    uppy.on("error", handleError);
+    return () => {
+      uppy.off("complete", handleComplete);
+      uppy.off("error", handleError);
+    };
+  }, [uppy]);
+  useEffect(() => {
+    try {
+      const preprocessor = cloudImportService.getPreprocessor();
+      preprocessor.setCreateFn(createMediaItem ?? null);
+    } catch {
+    }
+  }, [createMediaItem]);
+  const openModal = useCallback(async () => {
+    if (getUploadMeta) {
+      try {
+        const meta = await getUploadMeta();
+        cloudImportService.setMeta(meta);
+      } catch (err) {
+        console.error("[Import] Failed to get upload metadata:", err);
+        return;
+      }
+    }
+    setIsOpen(true);
+  }, [getUploadMeta]);
+  const closeModal = useCallback(() => {
+    setIsOpen(false);
+  }, []);
+  return /* @__PURE__ */ jsx(ImportContext, { value: { openModal, closeModal, isOpen, uppy, available }, children: /* @__PURE__ */ jsxs(UppyContextProvider, { uppy, children: [
+    children,
+    dialogSlot
+  ] }) });
+}
+function useImport() {
+  const ctx = useContext(ImportContext);
+  if (!ctx) throw new Error("useImport must be used within <ImportProvider>");
+  return ctx;
+}
+function useImportIfAvailable() {
+  const ctx = useContext(ImportContext);
+  return ctx?.available ? ctx : null;
+}
+
+// src/cloudConfig.ts
+var ENVIRONMENTS = {
+  dev: {
+    convexUrl: "https://api-dev.cueframe.ai",
+    uploadSigningUrl: "http://localhost:8787"
+  },
+  staging: {
+    convexUrl: "https://api-dev.cueframe.ai",
+    uploadSigningUrl: "https://upload-signing.cueframelabs.workers.dev"
+  },
+  production: {
+    convexUrl: "https://api.cueframe.ai",
+    uploadSigningUrl: "https://upload.cueframe.ai"
+  }
+};
+function detectEnvironment(convexUrl) {
+  if (!convexUrl) return "dev";
+  if (/\b(api-dev|data-dev)\.cueframe\.ai/.test(convexUrl)) return "staging";
+  if (/\b(api|data)\.cueframe\.ai/.test(convexUrl)) return "production";
+  if (/\boceanic-dogfish-357\.convex\.(cloud|site)/.test(convexUrl)) return "staging";
+  if (/\bpolished-hawk-150\.convex\.(cloud|site)/.test(convexUrl)) return "production";
+  return "dev";
+}
+function getEndpoints(convexUrl) {
+  const env = detectEnvironment(convexUrl);
+  return ENVIRONMENTS[env];
+}
+
+// src/index.ts
+import {
+  useDropzone,
+  useUppyState,
+  useUppyEvent
+} from "@uppy/react";
+export {
+  ENVIRONMENTS,
+  ImportProvider,
+  cloudImportService,
+  detectEnvironment,
+  getEndpoints,
+  multipartUpload,
+  useDropzone,
+  useImport,
+  useImportIfAvailable,
+  useUppyEvent,
+  useUppyState
+};
+//# sourceMappingURL=index.js.map