@gentleduck/upload 0.2.6 → 0.3.0

package/dist/strategy.types-gg9ZStRe.d.ts

@@ -1,225 +0,0 @@
-//#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 extends string = string> = {
-  /** Strategy name (discriminant). */strategy: K; /** 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/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 extends keyof M & string> = {
-  file: File;
-  intent: M[K];
-  signal: AbortSignal;
-  transport: UploadTransport;
-  api: UploadApi<M, P, R>;
-  reportProgress: (p: {
-    uploadedBytes: number;
-    totalBytes: number;
-  }) => void;
-  readCursor: () => C[K] | undefined;
-  persistCursor: (cursor: C[K] | undefined) => void;
-};
-type UploadStrategy<M extends IntentMap, C extends CursorMap<M>, P extends string, R extends UploadResultBase, K extends keyof M & string> = {
-  id: K;
-  resumable: boolean;
-  start(ctx: StrategyCtx<M, C, P, R, K>): Promise<void>;
-};
-interface StrategyRegistry<M extends IntentMap, C extends CursorMap<M>, P extends string = string, R extends UploadResultBase = UploadResultBase> {
-  get<K extends keyof M & string>(id: K): UploadStrategy<M, C, P, R, K> | undefined;
-  has(id: string): id is keyof M & string;
-  set<K extends keyof M & string>(strategy: UploadStrategy<M, C, P, R, K>): void;
-}
-//#endregion
-export { AnyCursor as a, WithSignal as c, IntentBase as d, IntentMap as f, UploadTransport as i, UploadResultBase as l, StrategyRegistry as n, CursorMap as o, StrategyKey as p, UploadStrategy as r, UploadApi as s, StrategyCtx as t, AnyIntent as u };

package/src/__test__/effect-pool.test.ts

@@ -1,5 +0,0 @@
-// Tests in this file referenced a planned effect-pool / watchdog / regression
-// API that was never ported into `src/`. The intended surface (WaitForError,
-// runUpload handler, frozen snapshots, listener-error hooks, queue compaction,
-// rebind handler, etc.) does not exist. Deleted until the source-of-truth API
-// stabilizes.

package/src/__test__/id.test.ts

@@ -1,14 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { generateId } from '../core/utils/id'
-
-describe('generateId', () => {
-  test('starts with the `upload_` prefix', () => {
-    expect(generateId()).toMatch(/^upload_/)
-  })
-
-  test('produces unique values across many calls', () => {
-    const set = new Set<string>()
-    for (let i = 0; i < 10_000; i++) set.add(generateId())
-    expect(set.size).toBe(10_000)
-  })
-})

package/src/__test__/store-integration.test.ts

@@ -1,5 +0,0 @@
-// Tests in this file referenced a planned store API surface (store.flush,
-// store.destroy, store.dispose, store.has, store.purge, store.outcomes,
-// store.cleanup, store.isDestroyed, store.ready, rebind handler, tombstones,
-// onPersistenceLoopStarved, etc.) that does not exist in `src/`. Deleted
-// until the source-of-truth API stabilizes.

package/src/core/client/client.ts

@@ -1,50 +0,0 @@
-import { Defaults } from '../utils/constants'
-import type { Client } from './client.types'
-
-/**
- * Apply defaults to a partial {@link Client.IUploadConfig}.
- *
- * @param input Partial config from the caller. Nested groups
- *   (e.g. `effectQueueCompaction`) accept their own partial shape.
- * @returns Fully populated config with each numeric field clamped to a sane
- *   minimum.
- * @template P Purpose string union.
- * @author wildduck2 <https://github.com/wildduck2>
- */
-export function resolveUploadConfig<P extends string>(input?: Client.UploadConfigInput<P>): Client.IUploadConfig<P> {
-  return {
-    maxConcurrentUploads: Math.max(1, input?.maxConcurrentUploads ?? Defaults.MAX_CONCURRENT_UPLOADS),
-    autoStart: input?.autoStart,
-    progressThrottleMs: Math.max(0, input?.progressThrottleMs ?? Defaults.PROGRESS_THROTTLE_MS),
-    validation: input?.validation ?? {},
-    maxAttempts: Math.max(1, input?.maxAttempts ?? Defaults.MAX_ATTEMPTS),
-    retryPolicy: input?.retryPolicy,
-    maxItems: input?.maxItems === null ? null : Math.max(1, input?.maxItems ?? Defaults.MAX_ITEMS),
-    completedItemTTL: input?.completedItemTTL,
-    effectConcurrency: Math.max(1, input?.effectConcurrency ?? Defaults.EFFECT_CONCURRENCY),
-    effectTimeoutMs: Math.max(0, input?.effectTimeoutMs ?? Defaults.EFFECT_TIMEOUT_MS),
-    errorContextInMessage: input?.errorContextInMessage ?? false,
-    keepRawCause: input?.keepRawCause ?? false,
-    effectQueueCompaction: {
-      minHead: Math.max(1, input?.effectQueueCompaction?.minHead ?? 64),
-      ratioDenom: Math.max(2, input?.effectQueueCompaction?.ratioDenom ?? 2),
-      maxQueueLength:
-        input?.effectQueueCompaction?.maxQueueLength === null
-          ? null
-          : Math.max(1, input?.effectQueueCompaction?.maxQueueLength ?? 10_000),
-    },
-    checksumMaxSize:
-      input?.checksumMaxSize === undefined
-        ? null
-        : input.checksumMaxSize === null
-          ? null
-          : Math.max(0, input.checksumMaxSize),
-    checksumChunkBytes:
-      input?.checksumChunkBytes === undefined
-        ? null
-        : input.checksumChunkBytes === null
-          ? null
-          : Math.max(1, input.checksumChunkBytes),
-    strictRebindType: input?.strictRebindType ?? false,
-  }
-}

package/src/core/client/client.types.ts

@@ -1,184 +0,0 @@
-import type { Contracts } from '../contracts'
-import type { Engine } from '../engine/engine.types'
-import type { Reducer } from '../engine/reducer'
-import type { Store } from '../engine/store'
-import type { PersistenceError } from '../persistence/persistence.types'
-
-/**
- * Client-facing configuration, hooks, plugins, and retry policy types.
- *
- * @author wildduck2 <https://github.com/wildduck2>
- */
-export namespace Client {
-  // -------------------- Retry --------------------
-
-  /** Output of the retry policy. `delayMs` is a backoff before re-attempt. */
-  export type RetryDecision = { retryable: false } | { retryable: true; delayMs: number }
-
-  // -------------------- Config --------------------
-
-  /** Effect-queue compaction tuning knobs. */
-  export interface IEffectQueueCompaction {
-    /** Absolute head-count floor before compaction. Default 64. */
-    minHead: number
-    /** Triggers compaction when `head * denom > length`. Default 2. */
-    ratioDenom: number
-    /**
-     * Hard upper bound on queue length. New effects past this cap are
-     * dropped + logged. Defends against a pathological dispatch storm that
-     * grows the queue faster than compaction drains. `null` disables.
-     * Default `10_000`.
-     */
-    maxQueueLength: number | null
-  }
-
-  /** Global upload engine configuration. */
-  export interface IUploadConfig<P extends string> {
-    /** Maximum concurrent in-flight uploads. Default `3`. */
-    maxConcurrentUploads: number
-    /** Auto-start `ready` items. */
-    autoStart?: readonly P[] | ((purpose: P) => boolean)
-    /** Throttle for `upload.progress` events in ms. Default `100`. */
-    progressThrottleMs: number
-    /** Per-purpose validation rules. */
-    validation: Partial<Record<P, Contracts.IValidationRules>>
-    /** Maximum attempts per phase before a failure is final. Default `3`. */
-    maxAttempts: number
-    /** Override the default retry policy. */
-    retryPolicy?: (ctx: {
-      phase: 'intent' | 'upload' | 'complete'
-      attempt: number
-      error: Contracts.Error
-    }) => RetryDecision
-    /** Cap on items kept in state. Set to `null` for no cap. Default `100`. */
-    maxItems: number | null
-    /** Auto-remove `completed`/`canceled` items after this many ms. */
-    completedItemTTL?: number
-    /** Concurrency cap for side-effects. Default `8`. */
-    effectConcurrency: number
-    /** Per-effect watchdog timeout in ms. `0` disables. Default `60000`. */
-    effectTimeoutMs: number
-    /** Include file context in persisted error messages. Default `false` (PII). */
-    errorContextInMessage: boolean
-    /** Keep raw thrown value as `error.cause`. Default `false` (PII). */
-    keepRawCause: boolean
-    /** Effect-queue compaction tuning. */
-    effectQueueCompaction: IEffectQueueCompaction
-    /**
-     * Skip `crypto.subtle.digest` (and the dedupe lookup that depends on it)
-     * for files larger than this byte threshold. The browser has no streaming
-     * SHA-256, so digesting a 10GB file allocates 10GB of heap; the cap lets
-     * the consumer trade dedupe coverage for memory. Default `null` (no cap).
-     */
-    checksumMaxSize: number | null
-    /**
-     * Hash only the first N bytes of each file. Yields a fast approximate
-     * fingerprint at the cost of strict uniqueness: files that share the
-     * leading window collide. Combine with `size + lastModified + chunk
-     * checksum` on the backend to form a unique dedupe key. Default
-     * `null` (full-file hash, exact match).
-     *
-     * @remarks Set to a small value (e.g. `1024 * 64`) for fast
-     * checksums on very large files where exact dedupe is not
-     * required.
-     */
-    checksumChunkBytes: number | null
-    /**
-     * When `true`, `rebind` requires the rebound `File.type` to match the
-     * paused item's fingerprint type. Default `false` because browsers
-     * disagree on MIME detection (Safari often omits MIME types Chrome
-     * attaches). Enable when both sessions are guaranteed to run in the
-     * same browser/runtime.
-     */
-    strictRebindType: boolean
-  }
-
-  /**
-   * Partial form accepted by `createUploadStore`. Nested config groups
-   * (e.g. `effectQueueCompaction`) accept their own partial shape so
-   * callers can override one knob without restating the rest.
-   */
-  export type UploadConfigInput<P extends string> = Partial<Omit<IUploadConfig<P>, 'effectQueueCompaction'>> & {
-    effectQueueCompaction?: Partial<IEffectQueueCompaction>
-  }
-
-  // -------------------- Hooks --------------------
-
-  /** Optional observability hooks. Diagnostics / analytics / devtools / Sentry. */
-  export interface IUploadHooks<
-    M extends Contracts.IntentMap,
-    C extends Contracts.CursorMap<M>,
-    P extends string,
-    R extends Contracts.IResultBase = Contracts.IResultBase,
-  > {
-    /** Fires after every internal event applied by the reducer. */
-    onInternalEvent?: (event: Engine.InternalEvent<M, C, P, R>, state: Reducer.IState<M, C, P, R>) => void
-    /** Fires when a persistence adapter operation fails. */
-    onPersistenceError?: (error: PersistenceError) => void
-    /** Fires on listener / plugin / emitter / batch throws. */
-    onListenerError?: (
-      error: unknown,
-      context: { kind: 'subscriber' | 'plugin-setup' | 'emitter' | 'batch'; name?: string },
-    ) => void
-    /**
-     * Fires when the effect queue rejects a new effect because it is at
-     * `effectQueueCompaction.maxQueueLength`. Production telemetry hook so
-     * dropped effects are not silently swallowed. Passes the current queue
-     * length (`queueLength`), active in-flight effect count (`active`), the
-     * hard cap (`cap`), and the optional `localId` of the upload that
-     * triggered the enqueue (when the caller threaded it through).
-     */
-    onEffectDropped?: (context: { queueLength: number; active: number; cap: number; localId?: string }) => void
-    /**
-     * Fires when `scheduleWork`'s re-entrant pass loop hits the soft cap
-     * (default 100). Production telemetry hook so a runaway feedback
-     * loop is visible even when dev-mode `console.error` is gated out.
-     */
-    onScheduleStarved?: (context: { passes: number }) => void
-    /**
-     * Fires when `flushPersistence`'s trailing-flush loop hits the soft
-     * cap. A pathological feedback loop (e.g. `onPersistenceError`
-     * dispatching state changes that schedule another flush) would
-     * otherwise spin forever. Defaults to 100 trailing iterations.
-     */
-    onPersistenceLoopStarved?: (context: { passes: number }) => void
-  }
-
-  // -------------------- Plugin --------------------
-
-  /** Store plugin. Subscribed once at construction with a narrow store view. */
-  export interface IUploadPlugin<
-    M extends Contracts.IntentMap,
-    C extends Contracts.CursorMap<M>,
-    P extends string,
-    R extends Contracts.IResultBase = Contracts.IResultBase,
-  > {
-    /** Plugin name (used in debugging output + `onListenerError` context). */
-    name: string
-    /**
-     * Called once at construction. May return a `Promise` to delay
-     * `store.ready` until the plugin finishes initializing (e.g. fetching
-     * remote feature flags). Sync throws and async rejections are both
-     * routed through `onListenerError`.
-     *
-     * Wider surface than R23: plugins now also see `flush` / `cleanup` /
-     * `purge` / `has` / `waitFor` / `subscribe` so a plugin can await
-     * durability, do bulk operations, or subscribe via the public
-     * mechanism instead of holding raw `rt` references.
-     */
-    setup: (
-      ctx: Pick<
-        Store.IUploadStore<M, C, P, R>,
-        'on' | 'off' | 'dispatch' | 'getSnapshot' | 'subscribe' | 'waitFor' | 'flush' | 'cleanup' | 'purge' | 'has'
-      >,
-    ) => void | Promise<void>
-    /**
-     * Called once during `store.destroy()` so the plugin can release its
-     * own resources (timers, external subscriptions, network handles).
-     * May return a `Promise` -- `destroy()` awaits all plugin disposes
-     * before resolving. Sync throws and async rejections route through
-     * `onListenerError` and never reject `destroy()`.
-     */
-    dispose?: () => void | Promise<void>
-  }
-}

package/src/core/client/config.types.ts

@@ -1,77 +0,0 @@
-import type { UploadError, UploadValidationRules } from '../contracts'
-import {
-  DEFAULT_MAX_ATTEMPTS,
-  DEFAULT_MAX_CONCURRENT_UPLOADS,
-  DEFAULT_MAX_ITEMS,
-  DEFAULT_PROGRESS_THROTTLE_MS,
-} from '../utils/constants'
-import type { RetryDecision } from './retry.types'
-
-/**
- * Global upload engine configuration.
- *
- * @typeParam P - Union of allowed `purpose` strings for your app.
- */
-export 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}.
- */
-export type UploadConfigInput<P extends string> = Partial<UploadConfig<P>>
-
-/**
- * Normalizes user config by applying sensible defaults.
- */
-export function resolveUploadConfig<P extends string>(input?: UploadConfigInput<P>): UploadConfig<P> {
-  return {
-    maxConcurrentUploads: Math.max(1, input?.maxConcurrentUploads ?? DEFAULT_MAX_CONCURRENT_UPLOADS),
-    autoStart: input?.autoStart,
-    progressThrottleMs: Math.max(0, input?.progressThrottleMs ?? DEFAULT_PROGRESS_THROTTLE_MS),
-    validation: input?.validation ?? {},
-    maxAttempts: Math.max(1, input?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS),
-    retryPolicy: input?.retryPolicy,
-    maxItems: Math.max(1, input?.maxItems ?? DEFAULT_MAX_ITEMS),
-    completedItemTTL: input?.completedItemTTL,
-  }
-}

package/src/core/client/index.ts

@@ -1,4 +0,0 @@
-export * from './config.types'
-export * from './plugins.types'
-export * from './retry.types'
-export * from './uploadClient'

package/src/core/client/plugins.types.ts

@@ -1,46 +0,0 @@
-import type { CursorMap, IntentMap, UploadResultBase } from '../contracts'
-import type { InternalEvent } from '../engine/internal-events.types'
-import type { UploadStore } from '../engine/store'
-
-/**
- * Optional hooks for observing internal behavior.
- *
- * Use these for diagnostics, analytics, logging, or devtools.
- */
-export 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: import('../engine/reducer').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.
- */
-export 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
-}

package/src/core/client/retry.types.ts

@@ -1,6 +0,0 @@
-/**
- * Output of the retry policy.
- *
- * `delayMs` should be a backoff delay before re-attempting the failed step.
- */
-export type RetryDecision = { retryable: false } | { retryable: true; delayMs: number }

package/src/core/client/uploadClient.ts

@@ -1,19 +0,0 @@
-import type { CursorMap, IntentMap, UploadResultBase } from '../contracts'
-import type { StoreOptions, UploadStore } from '../engine/store'
-import { createUploadStore } from '../engine/store'
-
-export type UploadClient<
-  M extends IntentMap,
-  C extends CursorMap<M>,
-  P extends string,
-  R extends UploadResultBase = UploadResultBase,
-> = UploadStore<M, C, P, R>
-
-export 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> {
-  return createUploadStore(opts)
-}