@devultur/convex 1.5.0 → 1.5.2

package/dist/react/contexts.js

@@ -0,0 +1,22 @@
+"use client";
+import "../chunk-O76FU54F.js";
+import {
+  DevulturApiContext,
+  DevulturContext,
+  DevulturProgressContext,
+  useCanDeliver,
+  useDevultur,
+  useDevulturApi,
+  useDevulturOptional,
+  useDevulturProgress
+} from "../chunk-FOBFHC4A.js";
+export {
+  DevulturApiContext,
+  DevulturContext,
+  DevulturProgressContext,
+  useCanDeliver,
+  useDevultur,
+  useDevulturApi,
+  useDevulturOptional,
+  useDevulturProgress
+};

package/dist/react/hooks.d.ts

@@ -0,0 +1,39 @@
+import { DevulturMedia } from '@devultur/core';
+import { M as MediaRenderOptions } from '../contexts-6F8TJINX.js';
+export { D as DevulturApi, b as DevulturApiContext, c as DevulturContext, d as DevulturContextValue, e as DevulturProgressContext, f as DevulturProgressContextValue, U as UploadOptions, g as UploadedMedia, u as useCanDeliver, i as useDevultur, j as useDevulturApi, k as useDevulturOptional, l as useDevulturProgress } from '../contexts-6F8TJINX.js';
+import 'react';
+import '@devultur/react';
+import 'convex/server';
+import 'convex/values';
+
+/**
+ * Ready-to-use delivery URL for a key, with the context's viewer token already injected. The consumer
+ * never touches the token or the query — it only declares what it wants (download, resize, etc.).
+ *
+ * @example
+ * <img src={useMediaUrl(key)} />
+ * <a href={useMediaUrl(key, { download: true })} download>Download</a>
+ * <img src={useMediaUrl(key, { width: 512, format: "webp" })} />
+ */
+declare function useMediaUrl(key: string | null | undefined, options?: MediaRenderOptions): string | null;
+interface VideoProps {
+    src: string;
+    token: string | undefined;
+    captions: {
+        locale: string;
+        label: string;
+        src: string;
+    }[];
+    /** Session secret → `<VideoPlayer>` sends it in `${SESSION_HEADER}` on hls.js/captions requests. */
+    sessionSecret?: string;
+}
+/**
+ * Token-transparent props for `<VideoPlayer>` from a video reference: builds the HLS playlist `src`,
+ * the viewer `token` (only if private), and the `captions` for the requested locales.
+ * The consumer just does `<VideoPlayer {...useVideoProps(lesson.video, { locales })} />`.
+ */
+declare function useVideoProps(media: DevulturMedia | null | undefined, options?: {
+    locales?: string[];
+}): VideoProps | null;
+
+export { type VideoProps, useMediaUrl, useVideoProps };

package/dist/react/hooks.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  useMediaUrl,
+  useVideoProps
+} from "../chunk-AUAWZ5BD.js";
+import "../chunk-O76FU54F.js";
+import {
+  DevulturApiContext,
+  DevulturContext,
+  DevulturProgressContext,
+  useCanDeliver,
+  useDevultur,
+  useDevulturApi,
+  useDevulturOptional,
+  useDevulturProgress
+} from "../chunk-FOBFHC4A.js";
+export {
+  DevulturApiContext,
+  DevulturContext,
+  DevulturProgressContext,
+  useCanDeliver,
+  useDevultur,
+  useDevulturApi,
+  useDevulturOptional,
+  useDevulturProgress,
+  useMediaUrl,
+  useVideoProps
+};

package/dist/react.d.ts

@@ -1,134 +1,18 @@
 import React from 'react';
-import { DevulturMedia, MediaUrlOptions, Visibility, ProcessingPhase, FailureReason, MediaStatusValue } from '@devultur/core';
-import { UploadProgress, BakeOutputFormat, MediaUploadState, MediaUploadError } from '@devultur/react';
+import { V as ViewerTokenAction, a as ViewerTokenArgs, D as DevulturApi } from './contexts-6F8TJINX.js';
+export { b as DevulturApiContext, c as DevulturContext, d as DevulturContextValue, e as DevulturProgressContext, f as DevulturProgressContextValue, T as TokenStatus, U as UploadOptions, g as UploadedMedia, h as ViewerTokenResult, u as useCanDeliver, i as useDevultur, j as useDevulturApi, k as useDevulturOptional, l as useDevulturProgress } from './contexts-6F8TJINX.js';
+import { BakeOutputFormat, MediaUploadState, MediaUploadError } from '@devultur/react';
 export { MediaUploadError, MediaUploadState, UploadProgress } from '@devultur/react';
-import { FunctionReference } from 'convex/server';
-import { Value } from 'convex/values';
-import { A as AttachmentLabels, M as MediaLibraryLabels, P as PreviewLabels, a as MediaPickerLabels, b as MediaFetchError } from './preview-labels-C2nUUY_f.js';
+import { A as AttachmentLabels, b as MediaFetchError, M as MediaLibraryLabels, P as PreviewLabels, a as MediaPickerLabels } from './preview-labels-C2nUUY_f.js';
 export { c as AttachmentKind, d as MediaFetchErrorCode, e as defaultAttachmentLabels, f as defaultMediaLibraryLabels, g as defaultMediaPickerLabels, h as defaultPreviewLabels, i as formatDuration, j as formatFileSize } from './preview-labels-C2nUUY_f.js';
+import { Visibility, DevulturMedia, MediaUrlOptions, MediaStatusValue, ProcessingPhase, FailureReason } from '@devultur/core';
+import { VideoProps } from './react/hooks.js';
+export { useMediaUrl, useVideoProps } from './react/hooks.js';
 import { M as MediaRecord } from './types-C0ruHUcu.js';
 import { P as PdfjsLoader } from './pdf-render-BwJGagvz.js';
 export { a as PdfjsModule } from './pdf-render-BwJGagvz.js';
-
-/** What a viewer token action returns: the token with its lifetime, or the bare token (default lifetime). */
-type ViewerTokenResult = {
-    token: string;
-    expiresIn: number;
-} | string;
-/** Extra arguments sent with `sessionSecret` to the viewer token action. */
-type ViewerTokenArgs = Record<string, Value>;
-/**
- * Where the viewer token for the current `tokenArgs` stands: not requested yet, being issued (no token yet), held, or
- * failed (the action threw or returned no token). A renewal in flight, or one that failed, keeps `"ready"`.
- */
-type TokenStatus = "idle" | "loading" | "ready" | "error";
-
-/** Transform/delivery options for media URLs (without `token`, which the context injects). */
-type MediaRenderOptions = Omit<MediaUrlOptions, "token">;
-/**
- * The viewer token action: the component's `issueViewerToken` (as `defineDevulturFunctions` or `exposeApi` export it,
- * where `sessionSecret` is optional) or an app's own, which may require it. The providers always send it.
- */
-type ViewerTokenAction = FunctionReference<"action", "public", {
-    sessionSecret?: string;
-}>;
-interface MediaSession {
-    token: string | null;
-    /** Where the viewer token stands; `"error"` makes private previews fail fast with `token_unavailable`. */
-    tokenStatus: TokenStatus;
-    /** Why the last issuance failed (the action threw or returned no token), while `tokenStatus` is `"error"`. */
-    tokenError: Error | null;
-    /** Issues the viewer token again (after a failure, for example). Resolves to the new token, or `null`. */
-    retryToken: () => Promise<string | null>;
-    /**
-     * Asks for the viewer token where it's issued lazily (`<DevulturViewerProvider lazyToken>`): the first private media
-     * shown calls it, and so must code that reads `token` itself. A no-op once asked, and where the token is issued
-     * right away (the default).
-     */
-    requestToken: () => void;
-    baseUrl: string | null;
-    /** Browser session secret → sent in `${SESSION_HEADER}` on every private delivery. */
-    sessionSecret: string;
-    /** Delivery URL from a reference (non-hook → usable in handlers and `.map`). Token-transparent. */
-    url: (media: DevulturMedia, options?: MediaRenderOptions) => string;
-    /** Downloads a video's subtitle text for a locale (auth-transparent). */
-    getCaptionsText: (media: DevulturMedia, locale: string) => Promise<string>;
-    /**
-     * Re-issues the viewer token (new session fingerprint with the current UA/IP) and updates the context.
-     * Single-flight: concurrent calls share the same issuance. Returns the new token (or null if it
-     * failed). The render uses it to transparently recover from a 401 `session_mismatch`.
-     */
-    reissueToken: () => Promise<string | null>;
-}
-
-type AnyAction = FunctionReference<"action">;
-type AnyMutation = FunctionReference<"mutation">;
-type AnyQuery = FunctionReference<"query">;
-interface DevulturApi {
-    issueViewerToken: AnyAction;
-    createUploadUrl: AnyAction;
-    /** Records an upload in the component after its PUT, so it shows in `listMedia`. Optional (uploads still work). */
-    confirmUpload?: AnyAction;
-    deleteMedia: AnyAction;
-    /** Deletes the full folder of a video (raw/hls/thumbnails/captions). Required to delete videos. */
-    deleteVideo?: AnyAction;
-    /** Requests the transcode of an uploaded video. Required by `useMediaUpload` for auto-process. */
-    processVideo?: AnyAction;
-    getMedia?: AnyQuery;
-    /** The library, newest first. Required by `useMediaLibrary` and `<MediaLibrary>`. */
-    listMediaPage?: AnyQuery;
-    /** The library matching a search. Required by `useMediaLibrary` and `<MediaLibrary>` to search. */
-    searchMedia?: AnyQuery;
-    saveProgress?: AnyMutation;
-    loadProgress?: AnyQuery;
-    markComplete?: AnyMutation;
-    resetProgress?: AnyMutation;
-}
-interface UploadOptions {
-    /**
-     * Visibility override for this resource. Omitted → `config.upload.visibility` on your server, else the Worker's
-     * default by type. Your guard can still rewrite it.
-     */
-    visibility?: Visibility;
-    /** Progress of the PUT: bytes sent, total bytes and their fraction (0 to 1). */
-    onProgress?: (progress: UploadProgress) => void;
-    /** Aborts the PUT → `upload()` rejects with an `AbortError`. */
-    signal?: AbortSignal;
-    /** A PDF's page count to record with it, a hint (`countPdfPages` from `@devultur/convex/pdfjs` counts it). */
-    pageCount?: number;
-}
-/**
- * The reference `upload()` resolves to: a `DevulturMedia` whose `key` is always set (the uploaded object's key; a
- * video's raw file, what `processVideo` takes). It stores as-is in a `dv.media()` field.
- */
-type UploadedMedia = DevulturMedia & {
-    readonly key: string;
-};
-/**
- * What `useDevultur()` returns. Under a `<DevulturViewerProvider>`, `uploadUrl`, `upload` and `deleteMedia` throw a
- * `DevulturCapabilityError` (`capability_unavailable`).
- */
-interface DevulturContextValue extends MediaSession {
-    uploadUrl: (file: File) => Promise<{
-        url: string;
-        key: string;
-    }>;
-    /** Uploads a file (reporting progress), records it in the component, and returns the reference ready to save. */
-    upload: (file: File, options?: UploadOptions) => Promise<UploadedMedia>;
-    /** Deletes a media by reference: video → full folder; image/file → the object. */
-    deleteMedia: (media: DevulturMedia) => void;
-}
-declare function useDevultur(): DevulturContextValue;
-/**
- * `useDevultur()` for components that also render outside a provider: the same value under `<DevulturProvider>` or
- * `<DevulturViewerProvider>`, and `null` outside both instead of throwing.
- */
-declare function useDevulturOptional(): DevulturContextValue | null;
-/**
- * The `api` passed to `<DevulturProvider>`: your app's exported Devultur functions. Under a `<DevulturViewerProvider>`
- * it throws a `DevulturCapabilityError`.
- */
-declare function useDevulturApi(): DevulturApi;
+import 'convex/server';
+import 'convex/values';
 
 /** What `useDevultur()` can do only under a `<DevulturProvider>` given the matching actions. */
 type DevulturCapability = "upload" | "uploadUrl" | "deleteMedia" | "api";
@@ -234,6 +118,27 @@ interface AttachmentCardProps extends Omit<React.HTMLAttributes<HTMLElement>, "c
  */
 declare function AttachmentCard({ media, contentType, onOpen, preview, headingLevel, locale, labels, ...articleProps }: AttachmentCardProps): React.JSX.Element | null;
 
+interface DownloadLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href" | "download" | "media"> {
+    media: DevulturMedia | null | undefined;
+    /** Name it downloads as. Without this it uses the upload's original name. */
+    filename?: string;
+    /**
+     * A private download that failed: `token_unavailable` right away when the viewer token couldn't be issued
+     * (`useDevultur().retryToken()` tries again), `http_error` when the delivery refused it.
+     */
+    onDownloadError?: (error: MediaFetchError) => void;
+    children: React.ReactNode;
+}
+/**
+ * `<a>` that downloads a media with its original name (token-transparent). The worker serves it with
+ * `Content-Disposition: attachment`, so a click downloads the file instead of opening it in a tab.
+ *
+ * Private: an `<a download>` NAVIGATES, and a navigation can't send `${SESSION_HEADER}` → with session
+ * binding the gate gives a 401. So, for private media, we intercept the click, blob-fetch with the header
+ * (like private `<Image>`) and trigger the download from the object URL. Public keeps native navigation.
+ */
+declare function DownloadLink({ media, filename, onDownloadError, children, ...anchorProps }: DownloadLinkProps): React.JSX.Element | null;
+
 /** An explicit `srcSet` is passed through to the `<img>` as is, and wins over the one `widths` builds. */
 interface ImageProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, "src" | "width" | "height"> {
     /** Typed reference. `null`/`undefined` → renders `fallback` (or `externalFallback`). Its `alt` is the default `alt`. */
@@ -275,6 +180,68 @@ interface ImageProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, "sr
  */
 declare function Image({ media, width, height, fit, format, quality, widths, sizes, fallback, externalFallback, render, alt, onLoadError, ...imgProps }: ImageProps): React.JSX.Element;
 
+interface MediaStatusReturn {
+    status: MediaStatusValue;
+    /** Typed progress: `phase` is the pipeline step (no `as any`). */
+    progress: {
+        current: number;
+        total: number;
+        percent: number;
+        phase?: ProcessingPhase;
+    } | null;
+    error: string | null;
+    /** Categorized failure reason (null if it didn't fail). */
+    failureReason: FailureReason | null;
+    /** Whether the failure is retriable (null if it didn't fail). */
+    retriable: boolean | null;
+    isQueued: boolean;
+    isTranscoding: boolean;
+    isCaptioning: boolean;
+    isReady: boolean;
+    isFailed: boolean;
+    playlistUrl: string | null;
+    thumbnailKey: string | null;
+    captionLocales: string[];
+    duration: number | null;
+    isLoading: boolean;
+}
+declare function useDevulturMedia(key: string | null | undefined): MediaStatusReturn;
+interface CaptionTrack {
+    locale: string;
+    label: string;
+    src: string;
+}
+/**
+ * A video's pipeline state as a **discriminated union** on `phase`: the render is an exhaustive
+ * `switch` (no boolean ordering or `as any`), and adding a new phase is a compile error until it's
+ * handled. `processing` carries typed `step`/`percent`; `ready` carries the ref + props ready for
+ * `<VideoPlayer>` (token-transparent); `failed` carries a categorized `reason` + `retriable`.
+ */
+type VideoState = {
+    phase: "idle";
+} | {
+    phase: "queued";
+} | {
+    phase: "processing";
+    step: ProcessingPhase;
+    percent: number;
+} | {
+    phase: "ready";
+    media: DevulturMedia;
+    playlist: string;
+    duration: number;
+    captions: CaptionTrack[];
+    playerProps: VideoProps;
+} | {
+    phase: "failed";
+    reason: FailureReason;
+    message: string;
+    retriable: boolean;
+};
+declare function useVideoState(media: DevulturMedia | null | undefined, options?: {
+    locales?: string[];
+}): VideoState;
+
 /** What `renderItem` gets besides the record. */
 interface MediaLibraryItemState {
     /** The record's reference (`mediaFromRecord`), `null` for a record without a visibility. */
@@ -657,6 +624,38 @@ interface MediaLibraryState {
  */
 declare function useMediaLibrary(options?: UseMediaLibraryOptions): MediaLibraryState;
 
+interface UseMediaUploadOptions {
+    /** Resource visibility. Omitted → `config.upload.visibility`, else the Worker's default by type. Your guard can rewrite it. */
+    visibility?: Visibility;
+    /** Fires ONCE, at the persistence point (PUT done + transcode requested). */
+    onComplete?: (media: DevulturMedia) => void;
+    onError?: (error: MediaUploadError) => void;
+    /** Deletes this old video/asset after a successful PUT (best-effort). */
+    replaces?: DevulturMedia | null;
+    /** Auto-request the transcode for videos. Default `true`; `false` = upload the raw file unprocessed. */
+    process?: boolean;
+    /** Caption locales to request when transcoding. */
+    locales?: string[];
+}
+interface UseMediaUploadReturn {
+    /** Triggers the upload; resolves with the `DevulturMedia` at the persistence point, or `null` if cancelled/failed. */
+    upload: (file: File) => Promise<DevulturMedia | null>;
+    /** The reactive state machine for the full cycle. */
+    state: MediaUploadState;
+    /** Aborts the in-progress PUT (`uploading` phase). */
+    cancel: () => void;
+    /** Returns to `idle` and clears everything. */
+    reset: () => void;
+}
+/**
+ * Unified upload primitive: hides the seam between the (imperative) upload and the (reactive)
+ * transcode behind ONE state machine. The consumer calls `upload(file)`, persists the ref in
+ * `onComplete`, and renders a `switch` over `state.phase`. Video triggers the transcode on its own;
+ * image/file go straight to `ready`. Requires `createUploadUrl` + `getMedia` in the provider (and
+ * `processVideo` for video).
+ */
+declare function useMediaUpload(options?: UseMediaUploadOptions): UseMediaUploadReturn;
+
 interface DevulturViewerProviderProps {
     /** Media worker base (e.g. `https://media.your-domain.com`). */
     baseUrl: string;
@@ -694,15 +693,6 @@ interface DevulturViewerProviderProps {
  */
 declare function DevulturViewerProvider({ issueViewerToken, ...props }: DevulturViewerProviderProps): React.JSX.Element;
 
-interface ProgressContextValue {
-    save: (videoId: string, position: number) => Promise<void>;
-    load: (videoId: string) => Promise<{
-        lastPosition: number;
-        completedAt: Date | null;
-    } | null>;
-    markComplete: (videoId: string) => Promise<void>;
-    reset: (videoId: string) => Promise<void>;
-}
 interface DevulturProviderProps {
     api: DevulturApi;
     /** Media worker base (e.g. `https://media.your-domain.com`). Required for `useMediaUrl`. */
@@ -722,147 +712,5 @@ interface DevulturProviderProps {
     children: React.ReactNode;
 }
 declare function DevulturProvider({ api, baseUrl, tokenArgs, issueViewerToken, children }: DevulturProviderProps): React.JSX.Element;
-declare function useDevulturProgress(): ProgressContextValue;
-/**
- * Ready-to-use delivery URL for a key, with the context's viewer token already injected. The consumer
- * never touches the token or the query — it only declares what it wants (download, resize, etc.).
- *
- * @example
- * <img src={useMediaUrl(key)} />
- * <a href={useMediaUrl(key, { download: true })} download>Download</a>
- * <img src={useMediaUrl(key, { width: 512, format: "webp" })} />
- */
-declare function useMediaUrl(key: string | null | undefined, options?: MediaRenderOptions): string | null;
-interface VideoProps {
-    src: string;
-    token: string | undefined;
-    captions: {
-        locale: string;
-        label: string;
-        src: string;
-    }[];
-    /** Session secret → `<VideoPlayer>` sends it in `${SESSION_HEADER}` on hls.js/captions requests. */
-    sessionSecret?: string;
-}
-/**
- * Token-transparent props for `<VideoPlayer>` from a video reference: builds the HLS playlist `src`,
- * the viewer `token` (only if private), and the `captions` for the requested locales.
- * The consumer just does `<VideoPlayer {...useVideoProps(lesson.video, { locales })} />`.
- */
-declare function useVideoProps(media: DevulturMedia | null | undefined, options?: {
-    locales?: string[];
-}): VideoProps | null;
-interface DownloadLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href" | "download" | "media"> {
-    media: DevulturMedia | null | undefined;
-    /** Name it downloads as. Without this it uses the upload's original name. */
-    filename?: string;
-    /**
-     * A private download that failed: `token_unavailable` right away when the viewer token couldn't be issued
-     * (`useDevultur().retryToken()` tries again), `http_error` when the delivery refused it.
-     */
-    onDownloadError?: (error: MediaFetchError) => void;
-    children: React.ReactNode;
-}
-/**
- * `<a>` that downloads a media with its original name (token-transparent). The worker serves it with
- * `Content-Disposition: attachment`, so a click downloads the file instead of opening it in a tab.
- *
- * Private: an `<a download>` NAVIGATES, and a navigation can't send `${SESSION_HEADER}` → with session
- * binding the gate gives a 401. So, for private media, we intercept the click, blob-fetch with the header
- * (like private `<Image>`) and trigger the download from the object URL. Public keeps native navigation.
- */
-declare function DownloadLink({ media, filename, onDownloadError, children, ...anchorProps }: DownloadLinkProps): React.JSX.Element | null;
-interface MediaStatusReturn {
-    status: MediaStatusValue;
-    /** Typed progress: `phase` is the pipeline step (no `as any`). */
-    progress: {
-        current: number;
-        total: number;
-        percent: number;
-        phase?: ProcessingPhase;
-    } | null;
-    error: string | null;
-    /** Categorized failure reason (null if it didn't fail). */
-    failureReason: FailureReason | null;
-    /** Whether the failure is retriable (null if it didn't fail). */
-    retriable: boolean | null;
-    isQueued: boolean;
-    isTranscoding: boolean;
-    isCaptioning: boolean;
-    isReady: boolean;
-    isFailed: boolean;
-    playlistUrl: string | null;
-    thumbnailKey: string | null;
-    captionLocales: string[];
-    duration: number | null;
-    isLoading: boolean;
-}
-declare function useDevulturMedia(key: string | null | undefined): MediaStatusReturn;
-interface CaptionTrack {
-    locale: string;
-    label: string;
-    src: string;
-}
-/**
- * A video's pipeline state as a **discriminated union** on `phase`: the render is an exhaustive
- * `switch` (no boolean ordering or `as any`), and adding a new phase is a compile error until it's
- * handled. `processing` carries typed `step`/`percent`; `ready` carries the ref + props ready for
- * `<VideoPlayer>` (token-transparent); `failed` carries a categorized `reason` + `retriable`.
- */
-type VideoState = {
-    phase: "idle";
-} | {
-    phase: "queued";
-} | {
-    phase: "processing";
-    step: ProcessingPhase;
-    percent: number;
-} | {
-    phase: "ready";
-    media: DevulturMedia;
-    playlist: string;
-    duration: number;
-    captions: CaptionTrack[];
-    playerProps: VideoProps;
-} | {
-    phase: "failed";
-    reason: FailureReason;
-    message: string;
-    retriable: boolean;
-};
-declare function useVideoState(media: DevulturMedia | null | undefined, options?: {
-    locales?: string[];
-}): VideoState;
-interface UseMediaUploadOptions {
-    /** Resource visibility. Omitted → `config.upload.visibility`, else the Worker's default by type. Your guard can rewrite it. */
-    visibility?: Visibility;
-    /** Fires ONCE, at the persistence point (PUT done + transcode requested). */
-    onComplete?: (media: DevulturMedia) => void;
-    onError?: (error: MediaUploadError) => void;
-    /** Deletes this old video/asset after a successful PUT (best-effort). */
-    replaces?: DevulturMedia | null;
-    /** Auto-request the transcode for videos. Default `true`; `false` = upload the raw file unprocessed. */
-    process?: boolean;
-    /** Caption locales to request when transcoding. */
-    locales?: string[];
-}
-interface UseMediaUploadReturn {
-    /** Triggers the upload; resolves with the `DevulturMedia` at the persistence point, or `null` if cancelled/failed. */
-    upload: (file: File) => Promise<DevulturMedia | null>;
-    /** The reactive state machine for the full cycle. */
-    state: MediaUploadState;
-    /** Aborts the in-progress PUT (`uploading` phase). */
-    cancel: () => void;
-    /** Returns to `idle` and clears everything. */
-    reset: () => void;
-}
-/**
- * Unified upload primitive: hides the seam between the (imperative) upload and the (reactive)
- * transcode behind ONE state machine. The consumer calls `upload(file)`, persists the ref in
- * `onComplete`, and renders a `switch` over `state.phase`. Video triggers the transcode on its own;
- * image/file go straight to `ready`. Requires `createUploadUrl` + `getMedia` in the provider (and
- * `processVideo` for video).
- */
-declare function useMediaUpload(options?: UseMediaUploadOptions): UseMediaUploadReturn;
 
-export { AttachmentCard, type AttachmentCardProps, AttachmentLabels, type CaptionTrack, CropUpload, type CropUploadLabels, type CropUploadProps, type CropUploadRenderProps, type DevulturApi, type DevulturCapability, DevulturCapabilityError, type DevulturContextValue, DevulturProvider, DevulturViewerProvider, type DevulturViewerProviderProps, DocumentLink, type DocumentLinkProps, DownloadLink, Image, type ImageProps, MediaFetchError, MediaLibrary, type MediaLibraryItemState, MediaLibraryLabels, type MediaLibraryPart, type MediaLibraryProps, type MediaLibraryState, type MediaLibraryStatus, type MediaObjectUrl, MediaPicker, MediaPickerLabels, type MediaPickerLibraryProps, type MediaPickerProps, type MediaPickerSelectionProps, type MediaPickerState, type MediaPickerUpload$1 as MediaPickerUpload, type MediaPickerUploadProps, type MediaPickerUploads, type PdfPreviewConfig, PdfPreviewProvider, PdfThumbnail, type PdfThumbnailProps, PdfjsLoader, Preview, type PreviewKind, PreviewLabels, type PreviewProps, type TokenStatus, type UploadOptions, type UploadedMedia, type UseMediaLibraryOptions, type UseMediaObjectUrlOptions, type UseMediaUploadOptions, type UseMediaUploadReturn, type VideoProps, type VideoState, type ViewerTokenArgs, type ViewerTokenResult, matchesAccept, useDevultur, useDevulturApi, useDevulturMedia, useDevulturOptional, useDevulturProgress, useMediaLibrary, useMediaObjectUrl, useMediaPicker, useMediaUpload, useMediaUrl, useVideoProps, useVideoState };
+export { AttachmentCard, type AttachmentCardProps, AttachmentLabels, type CaptionTrack, CropUpload, type CropUploadLabels, type CropUploadProps, type CropUploadRenderProps, DevulturApi, type DevulturCapability, DevulturCapabilityError, DevulturProvider, DevulturViewerProvider, type DevulturViewerProviderProps, DocumentLink, type DocumentLinkProps, DownloadLink, type DownloadLinkProps, Image, type ImageProps, MediaFetchError, MediaLibrary, type MediaLibraryItemState, MediaLibraryLabels, type MediaLibraryPart, type MediaLibraryProps, type MediaLibraryState, type MediaLibraryStatus, type MediaObjectUrl, MediaPicker, MediaPickerLabels, type MediaPickerLibraryProps, type MediaPickerProps, type MediaPickerSelectionProps, type MediaPickerState, type MediaPickerUpload$1 as MediaPickerUpload, type MediaPickerUploadProps, type MediaPickerUploads, type MediaStatusReturn, type PdfPreviewConfig, PdfPreviewProvider, PdfThumbnail, type PdfThumbnailProps, PdfjsLoader, Preview, type PreviewKind, PreviewLabels, type PreviewProps, type UseMediaLibraryOptions, type UseMediaObjectUrlOptions, type UseMediaUploadOptions, type UseMediaUploadReturn, VideoProps, type VideoState, ViewerTokenArgs, matchesAccept, useDevulturMedia, useMediaLibrary, useMediaObjectUrl, useMediaPicker, useMediaUpload, useVideoState };