@gentleduck/upload 0.2.2 → 0.2.5

package/dist/index.d.ts

@@ -1,1417 +1,5 @@
-import { ReactNode } from "react";
-
-//#region src/core/contracts/intent.types.d.ts
-
-/**
- * Base shape for all upload intents.
- *
- * An "intent" is data provided by your backend that tells the client how to upload a file
- * (for example: a presigned POST, presigned PUT, multipart upload IDs, part URLs, headers, etc).
- *
- * Every intent must include:
- * - `strategy`: a discriminant used to select an upload strategy implementation
- * - `fileId`: a stable backend identifier for the file being uploaded
- *
- * @typeParam K - Strategy key / discriminant string (example: `"direct" | "multipart"`).
- */
-type IntentBase<K$1 extends string = string> = {
-  /** Strategy name (discriminant). */
-  strategy: K$1;
-  /** Unique backend file identifier. */
-  fileId: string;
-};
-/**
- * Registry of intent types mapped by strategy name.
- *
- * Example:
- * ```ts
- * type MyIntents = {
- *   direct: DirectIntent
- *   multipart: MultipartIntent
- * }
- * ```
- *
- * `M[keyof M]` is used throughout the engine as the "any intent" union.
- */
-type IntentMap = Record<string, IntentBase<string>>;
-/** Union of strategy keys for an intent map. */
-type StrategyKey<M extends IntentMap> = keyof M & string;
-/** Union of all intent variants for an intent map. */
-type AnyIntent<M extends IntentMap> = M[StrategyKey<M>];
-//#endregion
-//#region src/core/contracts/result.types.d.ts
-/**
- * Base shape for upload completion results returned by your backend.
- *
- * Extend this with any additional metadata you return (e.g. width/height, variants).
- */
-type UploadResultBase = {
-  /** Backend file identifier. */
-  fileId: string;
-  /** Storage key or path used for signed URLs. */
-  key: string;
-};
-//#endregion
-//#region src/core/contracts/backendApi.d.ts
-type WithSignal = {
-  signal?: AbortSignal;
-};
-interface UploadApi<M extends IntentMap, P extends string, R extends UploadResultBase = UploadResultBase> {
-  createIntent(args: {
-    purpose: P;
-    contentType: string;
-    size: number;
-    filename: string;
-    checksum?: string;
-  }, opts?: WithSignal): Promise<M[keyof M]>;
-  complete(args: {
-    fileId: string;
-  }, opts?: WithSignal): Promise<R>;
-  getSignedPreviewUrl?(args: {
-    fileId: string;
-    key: string;
-    purpose: P;
-  }, opts?: WithSignal): Promise<string>;
-  /**
-   * Optional support for finding existing files by checksum for deduplication.
-   * If implemented, the upload engine will check for existing files before uploading.
-   * If a file with the same checksum exists, the upload will be skipped and the existing file will be linked.
-   */
-  findByChecksum?(args: {
-    checksum: string;
-    purpose: P;
-  }, opts?: WithSignal): Promise<R | null>;
-  multipart?: {
-    signPart(args: {
-      fileId: string;
-      uploadId: string;
-      partNumber: number;
-      checksum?: string;
-    }, opts?: WithSignal): Promise<{
-      url: string;
-      headers?: Record<string, string>;
-    }>;
-    completeMultipart(args: {
-      fileId: string;
-      uploadId: string;
-      parts: Array<{
-        partNumber: number;
-        etag: string;
-      }>;
-    }, opts?: WithSignal): Promise<unknown>;
-    listParts?(args: {
-      fileId: string;
-      uploadId: string;
-    }, opts?: WithSignal): Promise<Array<{
-      partNumber: number;
-      etag?: string;
-      size?: number;
-    }>>;
-    abort?(args: {
-      fileId: string;
-      uploadId: string;
-    }, opts?: WithSignal): Promise<void>;
-  };
-  tus?: {
-    create(args: {
-      fileId: string;
-      size: number;
-      filename: string;
-      contentType: string;
-    }, opts?: WithSignal): Promise<{
-      uploadUrl: string;
-    }>;
-    getOffset(args: {
-      uploadUrl: string;
-    }, opts?: WithSignal): Promise<{
-      offset: number;
-    }>;
-  };
-}
-//#endregion
-//#region src/core/contracts/cursor.types.d.ts
-/**
- * Registry of cursor payload types mapped by strategy name.
- *
- * A "cursor" is strategy-defined resume state (ex: multipart uploaded parts, next byte offset).
- * Use `unknown` here and define concrete cursor payload types in your app.
- *
- * @typeParam M - The intent map, used to constrain strategy keys.
- */
-type CursorMap<M extends IntentMap> = Partial<Record<StrategyKey<M>, unknown>>;
-/**
- * Discriminated union of all cursor variants.
- *
- * The cursor is always tagged with a `strategy` so it can be routed back to the correct strategy
- * on resume/rebind.
- *
- * @typeParam C - Cursor registry (usually {@link CursorMap}).
- */
-type AnyCursor<C extends Record<string, unknown>> = { [K in keyof C & string]: {
-  strategy: K;
-  value?: C[K];
-} }[keyof C & string];
-//#endregion
-//#region src/core/contracts/errors.types.d.ts
-/**
- * File rejection reasons produced by client-side validation.
- *
- * These should be safe to show in UI.
- */
-type RejectReason = {
-  code: 'empty_file';
-} | {
-  code: 'file_too_large';
-  maxBytes: number;
-  size: number;
-} | {
-  code: 'type_not_allowed';
-  allowed: string[];
-  got: string;
-} | {
-  code: 'too_many_files';
-  max: number;
-};
-/**
- * Base interface for custom errors.
- *
- * If you want to add domain-specific fields, extend this and intersect in {@link UploadError}.
- */
-interface UploadErrorBase {
-  /** Stable error code. */
-  code: string;
-  /** Human-friendly message (safe for UI). */
-  message: string;
-  /** Optional cause (original error, response, etc). */
-  cause?: unknown;
-  /** Whether the error should be retried. */
-  retryable?: boolean;
-}
-/**
- * Built-in engine errors.
- *
- * Keep these narrow and explicit so reducer logic can rely on `code` as a discriminant.
- */
-type BuiltInUploadError = {
-  code: 'validation_failed';
-  message: string;
-  reason: RejectReason;
-  retryable?: false;
-} | {
-  code: 'strategy_missing';
-  message: string;
-  strategy: string;
-  retryable?: false;
-} | {
-  code: 'aborted';
-  message: string;
-  reason: 'pause' | 'cancel' | 'unknown';
-  cause?: unknown;
-  retryable?: false;
-} | {
-  code: 'network';
-  message: string;
-  cause?: unknown;
-  retryable?: boolean;
-} | {
-  code: 'http';
-  message: string;
-  status: number;
-  statusText?: string;
-  cause?: unknown;
-  retryable?: boolean;
-} | {
-  code: 'timeout';
-  message: string;
-  cause?: unknown;
-  retryable?: boolean;
-} | {
-  code: 'auth';
-  message: string;
-  cause?: unknown;
-  retryable?: false;
-} | {
-  code: 'rate_limit';
-  message: string;
-  retryAfterMs?: number;
-  cause?: unknown;
-  retryable?: boolean;
-} | {
-  code: 'server';
-  message: string;
-  serverCode?: string;
-  cause?: unknown;
-  retryable?: boolean;
-} | {
-  code: 'unknown';
-  message: string;
-  cause?: unknown;
-  retryable?: boolean;
-};
-/**
- * The error type used everywhere in the engine.
- *
- * You can extend this by intersecting your own shape with {@link UploadErrorBase}
- * to add fields (example: `{ endpoint: string }`).
- */
-type UploadError = BuiltInUploadError | (UploadErrorBase & Record<string, unknown>);
-/**
- * Validation rules applied on `addFiles` before an item enters the upload pipeline.
- */
-type UploadValidationRules = {
-  /** Maximum number of files allowed. */
-  maxFiles?: number;
-  /** Maximum file size in bytes. */
-  maxSizeBytes?: number;
-  /** Minimum file size in bytes. */
-  minSizeBytes?: number;
-  /** Allowed MIME types. */
-  allowedTypes?: string[];
-  /** Allowed file extensions. */
-  allowedExtensions?: string[];
-};
-//#endregion
-//#region src/core/contracts/fingerprint.types.d.ts
-/**
- * Deterministic client-side identity for a file.
- *
- * Used to match the same file across refreshes (for rebind) and to deduplicate.
- * If you include `checksum`, it should be stable and computed consistently.
- */
-type FileFingerprint = {
-  /** File name. */
-  name: string;
-  /** File size in bytes. */
-  size: number;
-  /** File MIME type. */
-  type: string;
-  /** File lastModified timestamp (ms). */
-  lastModified: number;
-  /** Optional checksum (example: SHA-256 hex). */
-  checksum?: string;
-};
-//#endregion
-//#region src/core/contracts/transport/transport.types.d.ts
-/**
- * Abstraction layer for network operations.
- * Allows switching between XHR (browser) or other implementations (testing/Node).
- *
- * Designed to support:
- * - Deterministic progress tracking (requires XHR in browsers)
- * - Cancellation via AbortSignal
- * - Header parsing (ETag extraction)
- */
-interface UploadTransport {
-  /**
-   * Performs an HTTP PUT request (typically for S3 signed URLs).
-   */
-  put(args: {
-    url: string;
-    body: Blob;
-    headers?: Record<string, string>;
-    signal: AbortSignal;
-    onProgress?: (u: number, t: number) => void;
-  }): Promise<{
-    etag?: string;
-    headers?: Record<string, string>;
-  }>;
-  /**
-   * Performs an HTTP POST multipart request.
-   */
-  postForm(args: {
-    url: string;
-    fields: Record<string, string>;
-    file: File | Blob;
-    filename?: string;
-    signal: AbortSignal;
-    onProgress?: (uploadedBytes: number, totalBytes: number) => void;
-  }): Promise<{
-    etag?: string;
-    headers?: Record<string, string>;
-  }>;
-  /**
-   * Performs an HTTP request.
-   */
-  patch(args: {
-    url: string;
-    body: Blob | ArrayBuffer;
-    headers?: Record<string, string>;
-    signal: AbortSignal;
-    onProgress?: (u: number, t: number) => void;
-  }): Promise<{
-    headers?: Record<string, string>;
-  }>;
-}
-//#endregion
-//#region src/core/contracts/strategy.types.d.ts
-type StrategyCtx<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase, K$1 extends keyof M & string> = {
-  file: File;
-  intent: M[K$1];
-  signal: AbortSignal;
-  transport: UploadTransport;
-  api: UploadApi<M, P, R>;
-  reportProgress: (p: {
-    uploadedBytes: number;
-    totalBytes: number;
-  }) => void;
-  readCursor: () => C[K$1] | undefined;
-  persistCursor: (cursor: C[K$1] | undefined) => void;
-};
-type UploadStrategy<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase, K$1 extends keyof M & string> = {
-  id: K$1;
-  resumable: boolean;
-  start(ctx: StrategyCtx<M, C, P, R, K$1>): Promise<void>;
-};
-interface StrategyRegistry<M extends IntentMap, C extends CursorMap<M>, P extends string = string, R extends UploadResultBase = UploadResultBase> {
-  get<K$1 extends keyof M & string>(id: K$1): UploadStrategy<M, C, P, R, K$1> | undefined;
-  has(id: string): id is keyof M & string;
-  set<K$1 extends keyof M & string>(strategy: UploadStrategy<M, C, P, R, K$1>): void;
-}
-//#endregion
-//#region src/core/contracts/transport/transport.d.ts
-type XhrCommonArgs = {
-  url: string;
-  signal?: AbortSignal;
-  headers?: Record<string, string>;
-  onProgress?: (loaded: number, total: number) => void;
-};
-/**
- * Creates a browser-native XHR transport.
- * We use XMLHttpRequest instead of fetch because fetch does not yet support
- * upload progress events in a standard cross-browser way.
- */
-declare function createXHRTransport(): UploadTransport & {
-  patch?: (args: XhrCommonArgs & {
-    body: Blob | ArrayBuffer;
-  }) => Promise<{
-    headers: Record<string, string>;
-  }>;
-};
-//#endregion
-//#region src/core/client/retry.types.d.ts
-/**
- * Output of the retry policy.
- *
- * `delayMs` should be a backoff delay before re-attempting the failed step.
- */
-type RetryDecision = {
-  retryable: false;
-} | {
-  retryable: true;
-  delayMs: number;
-};
-//#endregion
-//#region src/core/client/config.types.d.ts
-/**
- * Global upload engine configuration.
- *
- * @typeParam P - Union of allowed `purpose` strings for your app.
- */
-type UploadConfig<P extends string> = {
-  /** Maximum concurrent uploads. */
-  maxConcurrentUploads: number;
-  /**
-   * Auto-start uploads for specific purposes.
-   * - Array form: only those purposes auto-start
-   * - Function form: dynamic decision per purpose
-   */
-  autoStart?: readonly P[] | ((purpose: P) => boolean);
-  /** Progress event throttle in milliseconds. */
-  progressThrottleMs: number;
-  /** Validation rules keyed by purpose. */
-  validation: Partial<Record<P, UploadValidationRules>>;
-  /** Maximum number of retry attempts (per item / per phase depending on implementation). */
-  maxAttempts: number;
-  /**
-   * Retry policy.
-   * Called whenever a phase fails and the engine needs a decision.
-   */
-  retryPolicy?: (ctx: {
-    phase: 'intent' | 'upload' | 'complete';
-    attempt: number;
-    error: UploadError;
-  }) => RetryDecision;
-  /**
-   * Maximum number of items to keep in state.
-   * When exceeded, oldest completed/canceled items are removed automatically.
-   *
-   * Set to `undefined` for no limit (not recommended for long-running apps).
-   * Default often: `100`.
-   */
-  maxItems: number;
-  /**
-   * Automatically remove completed items after this many milliseconds.
-   * Set to `undefined` to keep completed items indefinitely.
-   */
-  completedItemTTL?: number;
-};
-/**
- * Config input shape accepted by store creation.
- * All fields are optional; defaults are applied by {@link resolveUploadConfig}.
- */
-type UploadConfigInput<P extends string> = Partial<UploadConfig<P>>;
-/**
- * Normalizes user config by applying sensible defaults.
- */
-declare function resolveUploadConfig<P extends string>(input?: UploadConfigInput<P>): UploadConfig<P>;
-//#endregion
-//#region src/core/engine/commands.types.d.ts
-/**
- * Public commands accepted by the upload store.
- *
- * Reducer/effects should treat commands as "user intent".
- */
-type UploadCommand<P extends string> = {
-  type: 'addFiles';
-  files: File[];
-  purpose: P;
-} | {
-  type: 'start';
-  localId: string;
-} | {
-  type: 'startAll';
-  purpose?: P;
-} | {
-  type: 'pause';
-  localId: string;
-} | {
-  type: 'pauseAll';
-  purpose?: P;
-} | {
-  type: 'resume';
-  localId: string;
-} | {
-  type: 'cancel';
-  localId: string;
-} | {
-  type: 'cancelAll';
-  purpose?: P;
-} | {
-  type: 'retry';
-  localId: string;
-} | {
-  type: 'rebind';
-  localId: string;
-  file: File;
-} | {
-  type: 'remove';
-  localId: string;
-};
-//#endregion
-//#region src/core/engine/outcome.types.d.ts
-type UploadCompletionKind = 'upload' | 'dedupe';
-type UploadOutcome<R extends UploadResultBase> = {
-  localId: string;
-  status: 'completed';
-  completedBy: UploadCompletionKind;
-  result: R;
-} | {
-  localId: string;
-  status: 'error';
-  error: UploadError;
-} | {
-  localId: string;
-  status: 'canceled';
-} | {
-  localId: string;
-  status: 'missing';
-};
-//#endregion
-//#region src/core/engine/progress.types.d.ts
-/**
- * Upload progress snapshot.
- *
- * Invariants:
- * - `totalBytes` should be `file.size` when known.
- * - `pct` should be clamped to 0..100.
- */
-type UploadProgress = {
-  /** Bytes uploaded so far. */
-  uploadedBytes: number;
-  /** Total bytes to upload. */
-  totalBytes: number;
-  /** Percent complete (0..100). */
-  pct: number;
-};
-//#endregion
-//#region src/core/engine/internal-events.types.d.ts
-/**
- * Internal events emitted by effects and consumed by the reducer.
- *
- * These are not the same as public events. They are designed for correctness and state transitions.
- *
- * @typeParam M - Intent map
- * @typeParam C - Cursor map
- */
-type InternalEvent<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = {
-  type: 'files.added';
-  items: Array<{
-    localId: string;
-    purpose: P;
-    file: File;
-    fingerprint: FileFingerprint;
-    createdAt: number;
-  }>;
-} | {
-  type: 'fingerprint.updated';
-  localId: string;
-  fingerprint: FileFingerprint;
-} | {
-  type: 'validation.ok';
-  localId: string;
-} | {
-  type: 'validation.failed';
-  localId: string;
-  reason: RejectReason;
-} | {
-  type: 'intent.ok';
-  localId: string;
-  intent: AnyIntent<M>;
-} | {
-  type: 'intent.failed';
-  localId: string;
-  error: UploadError;
-  retryable: boolean;
-} | {
-  type: 'upload.begin';
-  localId: string;
-  startedAt: number;
-} | {
-  type: 'upload.progress';
-  localId: string;
-  uploadedBytes: number;
-  totalBytes: number;
-} | {
-  type: 'cursor.updated';
-  localId: string;
-  cursor: AnyCursor<C>;
-} | {
-  type: 'upload.ok';
-  localId: string;
-} | {
-  type: 'upload.failed';
-  localId: string;
-  error: UploadError;
-  retryable: boolean;
-} | {
-  type: 'dedupe.ok';
-  localId: string;
-  result: R;
-} | {
-  type: 'complete.ok';
-  localId: string;
-  result: R;
-} | {
-  type: 'complete.failed';
-  localId: string;
-  error: UploadError;
-  retryable: boolean;
-}
-/** Internal completion for pause requests. */ | {
-  type: 'paused';
-  localId: string;
-  cursor: AnyCursor<C>;
-  pausedAt: number;
-}
-/** Internal completion for cancel requests. */ | {
-  type: 'canceled';
-  localId: string;
-  canceledAt: number;
-};
-/**
- * All possible upload phases.
- *
- * Useful for constraints and UI filtering.
- */
-type UploadPhase = 'validating' | 'creating_intent' | 'ready' | 'queued' | 'uploading' | 'paused' | 'completing' | 'completed' | 'error' | 'canceled';
-/**
- * State of a single upload item.
- *
- * This is a discriminated union on `phase`.
- *
- * @typeParam M - Intent map
- * @typeParam C - Cursor map
- * @typeParam P - Purpose union
- */
-type UploadItem<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = {
-  /** Validating file against rules. */
-  phase: 'validating';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  file: File;
-  createdAt: number;
-} | {
-  /** Requesting upload intent from backend. */
-  phase: 'creating_intent';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  file: File;
-  /** Current attempt number for this phase. */
-  attempt: number;
-  createdAt: number;
-} | {
-  /** Intent received, ready to start upload. */
-  phase: 'ready';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  file: File;
-  intent: AnyIntent<M>;
-  createdAt: number;
-  cursor?: AnyCursor<C>;
-  progress?: UploadProgress;
-  attempt?: number;
-} | {
-  /** Queued for upload (waiting for slot). */
-  phase: 'queued';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  file: File;
-  intent: AnyIntent<M>;
-  /** Timestamp when this item requested a concurrency slot. */
-  requestedAt: number;
-  createdAt: number;
-  cursor?: AnyCursor<C>;
-  progress?: UploadProgress;
-  attempt?: number;
-} | {
-  /** Actively uploading bytes. */
-  phase: 'uploading';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  file: File;
-  intent: AnyIntent<M>;
-  startedAt: number;
-  progress: UploadProgress;
-  createdAt: number;
-  cursor?: AnyCursor<C>;
-  attempt?: number;
-} | {
-  /** Upload paused (resumable). */
-  phase: 'paused';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  intent: AnyIntent<M>;
-  cursor: AnyCursor<C>;
-  progress: UploadProgress;
-  pausedAt: number;
-  createdAt: number;
-  /**
-   * File is optional because a paused item can be restored from persistence without a File.
-   * Use `rebind` to attach the File again before resuming (when required).
-   */
-  file?: File;
-  attempt?: number;
-} | {
-  /** Bytes sent, finalizing with backend. */
-  phase: 'completing';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  file: File;
-  intent: AnyIntent<M>;
-  progress: UploadProgress;
-  completingAt: number;
-  createdAt: number;
-  attempt?: number;
-} | {
-  /** Upload completed successfully. */
-  phase: 'completed';
-  localId: string;
-  file: File;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  intent?: AnyIntent<M>;
-  completedBy: UploadCompletionKind;
-  result: R;
-  completedAt: number;
-  createdAt: number;
-  attempt?: number;
-} | {
-  /** Upload failed (retryable or final). */
-  phase: 'error';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  error: UploadError;
-  retryable: boolean;
-  attempt: number;
-  failedAt: number;
-  createdAt: number;
-  file?: File;
-  intent?: AnyIntent<M>;
-  cursor?: AnyCursor<C>;
-  progress?: UploadProgress;
-} | {
-  /** Upload canceled by user/system. */
-  phase: 'canceled';
-  localId: string;
-  purpose: P;
-  fingerprint: FileFingerprint;
-  canceledAt: number;
-  createdAt: number;
-  file?: File;
-  intent?: AnyIntent<M>;
-  cursor?: AnyCursor<C>;
-  progress?: UploadProgress;
-  attempt?: number;
-};
-//#endregion
-//#region src/core/engine/reducer.d.ts
-type UploadState<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = {
-  /** Map of uploads by localId for O(1) lookups */
-  items: Map<string, UploadItem<M, C, P, R>>;
-};
-declare function createReducer<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(): (state: UploadState<M, C, P, R>, event: UploadCommand<P> | InternalEvent<M, C, P, R>) => UploadState<M, C, P, R>;
-//#endregion
-//#region src/core/persistence/persistence.types.d.ts
-/**
- * A minimal, serializable representation of an upload item that is safe to store
- * in persistence (LocalStorage, IndexedDB, etc).
- *
- * This type is intentionally not the full {@link UploadItem} state.
- * It captures only the fields needed to:
- * - restore the UI list after refresh
- * - rebind an upload to its backend intent (if already created)
- * - resume an upload strategy from a known cursor (when supported)
- * - restore last-known progress and phase for UX continuity
- *
- * @typeParam M - Map of upload intent variants keyed by intent kind (e.g. `direct`, `multipart`).
- * @typeParam C - Map of cursor shapes keyed by {@link M}'s intent kinds.
- * @typeParam P - Union of allowed `purpose` strings for your app (e.g. `"avatar" | "document"`).
- */
-type PersistedSnapshot<M, C, P extends string> = {
-  /** Persistence schema version (not app version). */
-  version: number;
-  /** Unix epoch milliseconds when this snapshot was written. */
-  createdAt: number;
-  /** List of persisted upload items. */
-  items: Record<string, PersistedUploadItem<M, C, P>>;
-};
-type PersistedUploadItem<M, C, P extends string> = {
-  /** Stable, client-generated ID for this upload in local state. */
-  id: string;
-  /** File name. */
-  file: {
-    /** File name. */
-    name: string;
-    /** File size in bytes. */
-    size: number;
-    /** File MIME type. */
-    type: string;
-    /** File lastModified timestamp (ms). */
-    lastModified: number;
-    /** Optional checksum (example: SHA-256 hex). */
-    checksum?: string;
-  };
-  /** Backend-provided "intent" that describes how to upload (strategy, URLs, fields, etc). */
-  intent: M[keyof M];
-  /** Strategy cursor used to resume uploads that support continuation. */
-  cursor?: AnyCursor<C & Record<string, unknown>>;
-  /** Last-known progress for UX continuity after restoring from persistence. */
-  progress?: {
-    uploadedBytes: number;
-    totalBytes: number;
-    pct?: number;
-  };
-  /** The last known state-machine phase at the time of persistence. */
-  status: string;
-  /** Logical purpose for the upload (application-defined). */
-  purpose: P;
-};
-/**
- * A persisted snapshot of the upload store.
- *
- * Snapshots are versioned to allow safe migrations when the persistence schema evolves.
- * They are time-stamped for diagnostics and garbage-collection policies.
- */
-interface PersistenceAdapter {
-  /** Loads a snapshot from persistence. */
-  load(key: string): unknown | null | Promise<unknown | null>;
-  /** Saves a snapshot to persistence. */
-  save(key: string, snapshot: unknown): void | Promise<void>;
-  /** Clears a snapshot from persistence. */
-  clear(key: string): void | Promise<void>;
-}
-//#endregion
-//#region src/core/persistence/adapters.indexeddb.d.ts
-declare const IndexedDBAdapter: PersistenceAdapter;
-//#endregion
-//#region src/core/persistence/adapters.local.d.ts
-declare const LocalStorageAdapter: PersistenceAdapter;
-//#endregion
-//#region src/core/persistence/adapters.memory.d.ts
-declare const MemoryAdapter: PersistenceAdapter;
-//#endregion
-//#region src/core/persistence/persistence.d.ts
-/**
- * Serializes the current upload state into a JSON-safe structure.
- * Only serializes items that have a valid 'intent', as these are the only ones
- * that can be resumed cleanly.
- */
-declare function serializeSnapshot<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase>(state: UploadState<M, C, P, R>, version: number): PersistedSnapshot<M, C, P>;
-/**
- * Deserializes a persisted snapshot back into a store state.
- *
- * Important:
- * - Browser `File` objects cannot be restored from persistence.
- * - We restore resumable items (those with a cursor) into the `paused` phase,
- *   with `file` left undefined. Your UI can ask the user to rebind the file.
- */
-declare function deserializeSnapshot<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase>(raw: unknown, opts: {
-  isPurpose?: (value: string) => value is P;
-  isIntent?: (value: unknown) => value is M[keyof M];
-  hasStrategy: (value: string) => boolean;
-}): UploadState<M, C, P, R> | null;
-//#endregion
-//#region src/core/utils/emitter/emitter.types.d.ts
-/**
- * Minimal typed event emitter interface.
- *
- * Use this to expose strongly-typed events from your store.
- *
- * @typeParam E - Event map (`eventName -> payload`).
- */
-type TypedEmitter<E extends Record<string, unknown>> = {
-  /**
-   * Subscribe to an event.
-   * @returns Unsubscribe function.
-   */
-  on<K$1 extends keyof E & string>(type: K$1, cb: (payload: E[K$1]) => void): () => void;
-  /**
-   * Unsubscribe from an event.
-   * @returns Unsubscribe function.
-   */
-  off<K$1 extends keyof E & string>(type: K$1, cb: (payload: E[K$1]) => void): () => void;
-  /** Emit an event to all listeners. */
-  emit<K$1 extends keyof E & string>(type: K$1, payload: E[K$1]): void;
-};
-//#endregion
-//#region src/core/utils/emitter/index.d.ts
-declare function createTypedEmitter<E extends Record<string, unknown>>(): TypedEmitter<E>;
-//#endregion
-//#region src/core/engine/event-map.types.d.ts
-/**
- * Public event map emitted to consumers.
- *
- * Consumers subscribe via {@link TypedEmitter.on}.
- */
-type UploadEventMap<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = {
-  'file.added': {
-    localId: string;
-    purpose: P;
-    file: File;
-    fingerprint: FileFingerprint;
-  };
-  'file.rejected': {
-    file: File;
-    reason: RejectReason;
-  };
-  'validation.ok': {
-    localId: string;
-  };
-  'validation.failed': {
-    localId: string;
-    reason: RejectReason;
-  };
-  'intent.creating': {
-    localId: string;
-  };
-  'intent.created': {
-    localId: string;
-    intent: M[keyof M];
-  };
-  'intent.failed': {
-    localId: string;
-    error: UploadError;
-    retryable: boolean;
-  };
-  'upload.queued': {
-    localId: string;
-  };
-  'upload.resumed': {
-    localId: string;
-  };
-  'upload.started': {
-    localId: string;
-  };
-  'upload.progress': {
-    localId: string;
-    pct: number;
-    uploadedBytes: number;
-    totalBytes: number;
-  };
-  'upload.cursor': {
-    localId: string;
-    cursor: AnyCursor<C>;
-  };
-  'upload.paused': {
-    localId: string;
-    cursor: AnyCursor<C>;
-  };
-  'upload.canceled': {
-    localId: string;
-  };
-  'upload.completing': {
-    localId: string;
-  };
-  'upload.completed': {
-    localId: string;
-    result: R;
-    completedBy: UploadCompletionKind;
-  };
-  'upload.error': {
-    localId: string;
-    error: UploadError;
-    retryable: boolean;
-  };
-};
-//#endregion
-//#region src/core/engine/store/store.types.d.ts
-/**
- * Upload store interface used by UI adapters and application code.
- *
- * The store is intentionally minimal:
- * - state is read through {@link UploadStore.getSnapshot}
- * - updates are observed through {@link UploadStore.subscribe} and {@link UploadStore.on}
- * - actions are performed through {@link UploadStore.dispatch}
- *
- * @template M - Intent map type (keyed by strategy id)
- * @template C - Cursor map type (keyed by strategy id)
- * @template P - Purpose string union type
- */
-interface UploadStore<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> {
-  /**
-   * Returns the current immutable state snapshot.
-   * Useful for React loops or debugging.
-   */
-  getSnapshot(): UploadState<M, C, P, R>;
-  /**
-   * Subscribes to ANY state change.
-   * The listener is called after the reducer has run and effects have been scheduled.
-   * @param listener - Listener function to call on state change
-   */
-  subscribe(listener: () => void): () => void;
-  /**
-   * Main entry point for user actions.
-   * Converts external commands into internal state transitions and side effects.
-   *
-   * @param cmd The command to execute (e.g. 'addFiles', 'start', 'pause')
-   */
-  dispatch(cmd: UploadCommand<P>): void;
-  /**
-   * Subscribes to specific events (like 'file.added', 'upload.progress').
-   * Wraps the internal typed emitter.
-   */
-  on: <K$1 extends keyof UploadEventMap<M, C, P, R> & string>(type: K$1, cb: (payload: UploadEventMap<M, C, P, R>[K$1]) => void) => () => void;
-  /**
-   * Unsubscribes from specific events (like 'file.added', 'upload.progress').
-   * Wraps the internal typed emitter.
-   */
-  off: <K$1 extends keyof UploadEventMap<M, C, P, R> & string>(type: K$1, cb: (payload: UploadEventMap<M, C, P, R>[K$1]) => void) => () => void;
-  /**
-   * Waits for the given localIds to reach a terminal state.
-   */
-  waitFor(localIds: string[]): Promise<Array<UploadOutcome<R>>>;
-}
-/**
- * Options used to construct a store runtime.
- *
- * In practice you provide:
- * - a backend adapter ({@link UploadApi}) that creates intents and finalizes uploads
- * - a transport implementation (XHR, fetch, etc.) used by strategies
- * - a strategy registry describing what upload strategies exist and how to run them
- * - configuration rules for validation, concurrency, retries, and progress throttling
- *
- * Hooks and plugins are optional and let you observe or extend behavior without forking
- * the engine.
- *
- * @template M - Intent map type (keyed by strategy id)
- * @template C - Cursor map type (keyed by strategy id)
- * @template P - Purpose string union type
- */
-interface StoreOptions<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> {
-  /** Initial state to hydrate from (e.g. from localStorage) */
-  initialState?: UploadState<M, C, P, R>;
-  /** Static configuration rules (defaults are applied). */
-  config?: UploadConfigInput<P>;
-  /** Persistence adapter and options */
-  persistence?: PersistenceOptions<M, C, P, R>;
-  /** Backend API adapter for creating intents and finalizing uploads */
-  api: UploadApi<M, P, R>;
-  /** Network transport (XHR/Fetch) for the actual file data transfer */
-  transport?: UploadTransport;
-  /** Registry of available upload strategies (multipart, simple, etc.) */
-  strategies: StrategyRegistry<M, C, P, R>;
-  /** Optional plugins to extend functionality (e.g. debugging, metrics) */
-  plugins?: Array<UploadPlugin<M, C, P, R>>;
-  /** Lifecycle hooks for observing internal events */
-  hooks?: UploadHooks<M, C, P, R>;
-  /**
-   * Optional custom fingerprinting (e.g. include sha256).
-   * Must be synchronous to keep addFiles fast.
-   */
-  fingerprint?: (file: File) => FileFingerprint;
-  /**
-   * If returns non-null, it rejects the file.
-   * Runs after built-in config validation.
-   */
-  validateFile?: (file: File, purpose: P) => RejectReason | null;
-  /**
-   * Optional custom error normalizer.
-   * Convert raw errors (from fetch, XHR, etc.) into your custom UploadError shape.
-   */
-  errorNormalizer?: (err: unknown) => UploadError;
-}
-/**
- * Persistence options.
- *
- * Used to configure the upload store persistence layer.
- */
-type DeserializeContext<M extends IntentMap, C extends CursorMap<M>, P extends string> = {
-  isPurpose?: (value: string) => value is P;
-  isIntent?: (value: unknown) => value is M[keyof M];
-  hasStrategy: (value: string) => boolean;
-};
-type PersistenceOptions<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase> = {
-  /** Persistence key (e.g. localStorage key) */
-  key: string;
-  /** Persistence schema version (not app version) */
-  version: number;
-  /** Debounce delay in milliseconds (default: 200) */
-  debounceMs?: number;
-  /** Persistence adapter */
-  adapter: PersistenceAdapter;
-  /**
-   * Optional custom snapshot serializer.
-   * Convert the upload state into a JSON-safe snapshot.
-   */
-  serialize?: (state: UploadState<M, C, P, R>, version: number) => PersistedSnapshot<M, C, P>;
-  /**
-   * Optional custom snapshot deserializer.
-   * Convert a JSON-safe snapshot into the upload state.
-   */
-  deserialize?: (raw: unknown, ctx: DeserializeContext<M, C, P>) => UploadState<M, C, P, R> | null;
-  /**
-   * Runtime guard for purpose strings when using the default deserializer.
-   */
-  isPurpose?: (value: string) => value is P;
-  /**
-   * Runtime guard for intent objects when using the default deserializer.
-   */
-  isIntent?: (value: unknown) => value is M[keyof M];
-};
-/**
- * Internal record describing a currently running upload request.
- *
- * The store keeps one inflight entry per `localId` while the strategy's `start()` is running.
- * The {@link AbortController} is used to pause/cancel, while `mode` tracks which user intent
- * caused the abort so the handler can map it back into a correct state transition.
- */
-type InflightUpload = {
-  controller: AbortController;
-  mode: 'normal' | 'pause' | 'cancel';
-  started: boolean;
-};
-/**
- * Internal runtime container shared across dispatch, scheduler, and handlers.
- *
- * @template M - Intent map type
- * @template C - Cursor map type
- * @template P - Purpose string union type
- */
-type StoreRuntime<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = {
-  /** Store options */
-  opts: StoreOptions<M, C, P, R> & {
-    config: UploadConfig<P>;
-    transport: UploadTransport;
-  };
-  /** Current state */
-  state: UploadState<M, C, P, R>;
-  /** Listeners for external events */
-  listeners: Set<() => void>;
-  /** Typed event emitter */
-  emitter: TypedEmitter<UploadEventMap<M, C, P, R>>;
-  /** Reducer */
-  reduce: ReturnType<typeof createReducer<M, C, P, R>>;
-  /** In-flight uploads */
-  inflightUploads: Map<string, InflightUpload>;
-  /** In-flight intents */
-  inflightIntents: Map<string, AbortController>;
-  /** In-flight completes */
-  inflightCompletes: Map<string, AbortController>;
-  /** Effect queue */
-  effectQueue: Array<() => Promise<void>>;
-  /** Effect queue processing */
-  processingEffects: boolean;
-  /** Effect queue scheduling */
-  scheduling: boolean;
-  /** Notifies listeners */
-  notify: () => void;
-  /** Schedules work */
-  scheduleWork: () => void;
-  /** Applies an internal event */
-  applyInternal: (event: InternalEvent<M, C, P, R>) => void;
-  /** Applies a command */
-  applyCommand: (cmd: UploadCommand<P>) => void;
-  /** Enqueues an effect */
-  enqueueEffect: (effect: () => Promise<void>) => void;
-  /** Processes effects */
-  processEffects: () => Promise<void>;
-  /** Set by createUploadStore after construction; used by handlers for retries etc. */
-  dispatch: (cmd: UploadCommand<P>) => void;
-};
-//#endregion
-//#region src/core/engine/store/index.d.ts
-/**
- * Creates an upload store instance.
- *
- * This is the main runtime object you interact with from the outside:
- * - dispatch user commands (add files, start, pause, cancel, resume)
- * - subscribe to state changes (for UI rendering)
- * - subscribe to typed events (for progress, errors, and lifecycle)
- *
- * Plugins are initialized once during construction and receive a minimal store
- * proxy (events, dispatch, snapshot access) to avoid tight coupling.
- *
- * @template M - Intent map type (keyed by strategy id)
- * @template C - Cursor map type (keyed by strategy id)
- * @template P - Purpose string union type
- *
- * @param opts - Store options (config, backend API, strategies, transport, hooks)
- * @returns A configured {@link UploadStore} instance.
- */
-declare function createUploadStore<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(opts: StoreOptions<M, C, P, R>): UploadStore<M, C, P, R>;
-//#endregion
-//#region src/core/client/plugins.types.d.ts
-/**
- * Optional hooks for observing internal behavior.
- *
- * Use these for diagnostics, analytics, logging, or devtools.
- */
-type UploadHooks<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = {
-  /**
-   * Called after internal events are processed (depending on your runtime wiring).
-   * Prefer this over subscribing to public events if you need full fidelity.
-   */
-  onInternalEvent?: (event: InternalEvent<M, C, P, R>, state: UploadState<M, C, P, R>) => void;
-};
-/**
- * Store plugins.
- *
- * Plugins can subscribe to store events and dispatch commands.
- * They should not reach into internal state mutably.
- */
-type UploadPlugin<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = {
-  /** Plugin name (for debugging). */
-  name: string;
-  /**
-   * Setup callback called once when the store is created.
-   * The plugin can register event listeners and drive behavior.
-   */
-  setup: (ctx: Pick<UploadStore<M, C, P, R>, 'on' | 'dispatch' | 'getSnapshot'>) => void;
-};
-//#endregion
-//#region src/core/client/uploadClient.d.ts
-type UploadClient<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase> = UploadStore<M, C, P, R>;
-declare function createUploadClient<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(opts: StoreOptions<M, C, P, R>): UploadClient<M, C, P, R>;
-//#endregion
-//#region src/core/engine/validation/file.d.ts
-declare function validateFile<P extends string>(file: File, purpose: P, config: UploadConfig<P>): RejectReason | null;
-//#endregion
-//#region src/core/engine/validation/intent.d.ts
-declare function validateIntent(intent: unknown, strategy: string): Error | null;
-//#endregion
-//#region src/core/engine/validation/list.d.ts
-declare function validateFileList<P extends string>(files: File[], purpose: P, config: UploadConfig<P>, existingCount?: number): {
-  valid: File[];
-  rejected: Array<{
-    file: File;
-    reason: RejectReason;
-  }>;
-};
-//#endregion
-//#region src/core/utils/async.d.ts
-declare function sleep(ms: number): Promise<void>;
-//#endregion
-//#region src/core/utils/constants.d.ts
-/**
- * Default retry delay base in milliseconds.
- * Used for exponential backoff calculation: base * 2^(attempt - 1)
- */
-declare const DEFAULT_RETRY_DELAY_BASE_MS = 500;
-/**
- * Maximum retry delay in milliseconds.
- * Caps exponential backoff to prevent excessive delays.
- */
-declare const DEFAULT_RETRY_DELAY_MAX_MS = 10000;
-/**
- * Default progress event throttle in milliseconds.
- * Prevents excessive progress updates from overwhelming the UI.
- */
-declare const DEFAULT_PROGRESS_THROTTLE_MS = 100;
-/**
- * Default maximum number of retry attempts.
- */
-declare const DEFAULT_MAX_ATTEMPTS = 3;
-/**
- * Default maximum number of concurrent uploads.
- */
-declare const DEFAULT_MAX_CONCURRENT_UPLOADS = 3;
-/**
- * Default maximum number of items to keep in memory.
- */
-declare const DEFAULT_MAX_ITEMS = 100;
-//#endregion
-//#region src/core/utils/fingerprint.d.ts
-/**
- * Builds a lightweight fingerprint from a {@link File}.
- */
-declare function computeFingerprint(file: File): FileFingerprint;
-/**
- * Compares two file fingerprints.
- */
-declare function fingerprintMatches(a: FileFingerprint, b: FileFingerprint): boolean;
-//#endregion
-//#region src/core/utils/guards.d.ts
-declare function isRecord(value: unknown): value is Record<string, unknown>;
-//#endregion
-//#region src/core/utils/id.d.ts
-declare function generateId(): string;
-//#endregion
-//#region src/react/upload-provider.d.ts
-/**
- * Provider component that makes the upload store available to child components.
- *
- * @template M - Intent map type
- * @template C - Cursor map type
- * @template P - Purpose type
- *
- * @param props - Provider props
- * @param props.store - Upload store instance to provide
- * @param props.children - Child components that can access the store
- *
- * @returns {JSX.Element} Context provider wrapping children
- *
- * @example
- * ```tsx
- * <UploadProvider store={store}>
- *   <UploadDropzone purpose="avatar" />
- * </UploadProvider>
- * ```
- */
-declare function UploadProvider<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>({
-  store,
-  children
-}: {
-  store: UploadStore<M, C, P, R>;
-  children: ReactNode;
-}): React.JSX.Element;
-/**
- * Hook to access the upload store from React context.
- *
- * @template M - Intent map type
- * @template C - Cursor map type
- * @template P - Purpose type
- *
- * @returns {UploadStore<M, C, P>} The upload store instance
- * @throws {Error} If called outside of UploadProvider
- *
- * @example
- * ```tsx
- * const store = useUploadStore()
- * const snapshot = store.getSnapshot()
- * ```
- */
-declare function useUploadStore<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(): UploadStore<M, C, P, R>;
-//#endregion
-//#region src/react/use-uploader.d.ts
-declare function createUploadFactory<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(store: UploadStore<M, C, P, R>): () => Uploader<M, C, P, R>;
-type PickItemsByPhase<Phase extends UploadPhase> = Extract<UploadItem<IntentMap, CursorMap<IntentMap>, string, UploadResultBase>, {
-  phase: Phase;
-}>;
-type Uploader<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase> = {
-  items: UploadItem<M, C, P, R>[];
-  byPhase: Record<string, UploadItem<M, C, P, R>[]>;
-  dispatch: (cmd: UploadCommand<P>) => void;
-  on: <K$1 extends keyof UploadEventMap<M, C, P, R> & string>(type: K$1, cb: (payload: UploadEventMap<M, C, P, R>[K$1]) => void) => () => void;
-  off: <K$1 extends keyof UploadEventMap<M, C, P, R> & string>(type: K$1, cb: (payload: UploadEventMap<M, C, P, R>[K$1]) => void) => () => void;
-  uploading: UploadItem<M, C, P, R>[];
-  paused: UploadItem<M, C, P, R>[];
-  completed: UploadItem<M, C, P, R>[];
-  failed: UploadItem<M, C, P, R>[];
-  ready: UploadItem<M, C, P, R>[];
-};
-declare function useUploader<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(): Uploader<M, C, P, R>;
-declare function useUploader<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(store: UploadStore<M, C, P, R>): Uploader<M, C, P, R>;
-declare function useUploaderActions<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase = UploadResultBase>(): {
-  dispatch: (cmd: UploadCommand<P>) => void;
-  on: <K$1 extends keyof UploadEventMap<M_1, C_1, P_1, R_1> & string>(type: K$1, cb: (payload: UploadEventMap<M, C, P, R>[K$1]) => void) => () => void;
-  store: UploadStore<M, C, P, R>;
-};
-//#endregion
-//#region src/strategies/multipart/index.d.ts
-type MultipartIntent = {
-  strategy: 'multipart';
-  fileId: string;
-  uploadId: string;
-  partSize: number;
-  partCount: number;
-  parts?: Array<{
-    partNumber: number;
-    url: string;
-    headers?: Record<string, string>;
-  }>;
-};
-type MultipartCursor = {
-  done: Array<{
-    partNumber: number;
-    etag: string;
-    size: number;
-  }>;
-  /**
-   * Marks that the multipart session was completed on the backend (parts assembled).
-   * This prevents re-sending completeMultipart on resume.
-   */
-  completed?: true;
-};
-declare function multipartStrategy<M extends IntentMap & {
-  multipart: MultipartIntent;
-}, C extends CursorMap<M> & {
-  multipart?: MultipartCursor;
-}, P extends string = string, R extends UploadResultBase = UploadResultBase>(opts?: {
-  maxPartConcurrency?: number;
-}): UploadStrategy<M, C, P, R, 'multipart'>;
-//#endregion
-//#region src/strategies/post/index.d.ts
-type PostIntent = {
-  /** Strategy identifier - must be 'post' */
-  strategy: 'post';
-  /** Backend file identifier */
-  fileId: string;
-  /** Presigned POST URL (form action) */
-  url: string;
-  /** Form fields to include before the file */
-  fields: Record<string, string>;
-  /** Optional expiration timestamp for the presigned URL */
-  expiresAt?: string;
-};
-type PostCursor = {
-  /** Bytes uploaded (for progress display only) */
-  uploadedBytes: number;
-};
-declare function PostStrategy<M extends IntentMap & {
-  post: PostIntent;
-}, C extends CursorMap<M> & {
-  post?: PostCursor;
-}, P extends string = string, R extends UploadResultBase = UploadResultBase>(): UploadStrategy<M, C, P, R, 'post'>;
-//#endregion
-//#region src/strategies/registry/index.d.ts
-declare function createStrategyRegistry<M extends IntentMap, C extends CursorMap<M>, P extends string = string, R extends UploadResultBase = UploadResultBase>(): StrategyRegistry<M, C, P, R>;
-//#endregion
-export { AnyCursor, AnyIntent, BuiltInUploadError, CursorMap, DEFAULT_MAX_ATTEMPTS, DEFAULT_MAX_CONCURRENT_UPLOADS, DEFAULT_MAX_ITEMS, DEFAULT_PROGRESS_THROTTLE_MS, DEFAULT_RETRY_DELAY_BASE_MS, DEFAULT_RETRY_DELAY_MAX_MS, DeserializeContext, FileFingerprint, IndexedDBAdapter, InflightUpload, IntentBase, IntentMap, InternalEvent, LocalStorageAdapter, MemoryAdapter, MultipartCursor, MultipartIntent, PersistedSnapshot, PersistedUploadItem, PersistenceAdapter, PersistenceOptions, PickItemsByPhase, PostCursor, PostIntent, PostStrategy, RejectReason, RetryDecision, StoreOptions, StoreRuntime, type StrategyCtx, StrategyKey, type StrategyRegistry, type TypedEmitter, UploadApi, UploadClient, UploadCommand, UploadCompletionKind, UploadConfig, UploadConfigInput, UploadError, UploadErrorBase, UploadEventMap, UploadHooks, UploadItem, UploadOutcome, UploadPhase, UploadPlugin, UploadProgress, UploadProvider, UploadResultBase, UploadState, UploadStore, type UploadStrategy, UploadTransport, UploadValidationRules, WithSignal, computeFingerprint, createReducer, createStrategyRegistry, createTypedEmitter, createUploadClient, createUploadFactory, createUploadStore, createXHRTransport, deserializeSnapshot, fingerprintMatches, generateId, isRecord, multipartStrategy, resolveUploadConfig, serializeSnapshot, sleep, useUploadStore, useUploader, useUploaderActions, validateFile, validateFileList, validateIntent };
+import { a as AnyCursor, c as WithSignal, d as IntentBase, f as IntentMap, i as UploadTransport, l as UploadResultBase, n as StrategyRegistry, o as CursorMap, p as StrategyKey, r as UploadStrategy, s as UploadApi, t as StrategyCtx, u as AnyIntent } from "./strategy.types-gg9ZStRe.js";
+import { $ as RejectReason, A as serializeSnapshot, B as UploadItem, C as StoreOptions, D as createTypedEmitter, E as UploadEventMap, F as PersistedUploadItem, G as UploadCommand, H as UploadProgress, I as PersistenceAdapter, J as resolveUploadConfig, K as UploadConfig, L as UploadState, M as LocalStorageAdapter, N as IndexedDBAdapter, O as TypedEmitter, P as PersistedSnapshot, Q as BuiltInUploadError, R as createReducer, S as PersistenceOptions, T as UploadStore, U as UploadCompletionKind, V as UploadPhase, W as UploadOutcome, X as createXHRTransport, Y as RetryDecision, Z as FileFingerprint, _ as UploadHooks, a as DEFAULT_MAX_ATTEMPTS, b as DeserializeContext, c as DEFAULT_PROGRESS_THROTTLE_MS, d as sleep, et as UploadError, f as validateFileList, g as createUploadClient, h as UploadClient, i as fingerprintMatches, j as MemoryAdapter, k as deserializeSnapshot, l as DEFAULT_RETRY_DELAY_BASE_MS, m as validateFile, n as isRecord, nt as UploadValidationRules, o as DEFAULT_MAX_CONCURRENT_UPLOADS, p as validateIntent, q as UploadConfigInput, r as computeFingerprint, s as DEFAULT_MAX_ITEMS, t as generateId, tt as UploadErrorBase, u as DEFAULT_RETRY_DELAY_MAX_MS, v as UploadPlugin, w as StoreRuntime, x as InflightUpload, y as createUploadStore, z as InternalEvent } from "./index-BXg9WIce.js";
+import { PickItemsByPhase, UploadProvider, UploaderActions, createUploadFactory, useOptionalUploadStore, useUploadStore, useUploader, useUploaderActions } from "./react/index.js";
+import { MultipartCursor, MultipartIntent, PostCursor, PostIntent, PostStrategy, createStrategyRegistry, multipartStrategy } from "./strategies/index.js";
+export { AnyCursor, AnyIntent, BuiltInUploadError, CursorMap, DEFAULT_MAX_ATTEMPTS, DEFAULT_MAX_CONCURRENT_UPLOADS, DEFAULT_MAX_ITEMS, DEFAULT_PROGRESS_THROTTLE_MS, DEFAULT_RETRY_DELAY_BASE_MS, DEFAULT_RETRY_DELAY_MAX_MS, DeserializeContext, FileFingerprint, IndexedDBAdapter, InflightUpload, IntentBase, IntentMap, InternalEvent, LocalStorageAdapter, MemoryAdapter, MultipartCursor, MultipartIntent, PersistedSnapshot, PersistedUploadItem, PersistenceAdapter, PersistenceOptions, PickItemsByPhase, PostCursor, PostIntent, PostStrategy, RejectReason, RetryDecision, StoreOptions, StoreRuntime, StrategyCtx, StrategyKey, StrategyRegistry, TypedEmitter, UploadApi, UploadClient, UploadCommand, UploadCompletionKind, UploadConfig, UploadConfigInput, UploadError, UploadErrorBase, UploadEventMap, UploadHooks, UploadItem, UploadOutcome, UploadPhase, UploadPlugin, UploadProgress, UploadProvider, UploadResultBase, UploadState, UploadStore, UploadStrategy, UploadTransport, UploadValidationRules, UploaderActions, WithSignal, computeFingerprint, createReducer, createStrategyRegistry, createTypedEmitter, createUploadClient, createUploadFactory, createUploadStore, createXHRTransport, deserializeSnapshot, fingerprintMatches, generateId, isRecord, multipartStrategy, resolveUploadConfig, serializeSnapshot, sleep, useOptionalUploadStore, useUploadStore, useUploader, useUploaderActions, validateFile, validateFileList, validateIntent };