mvc-kit 2.9.0 → 2.10.0

package/dist/Pending.cjs

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("./errors.cjs");
+const bindPublicMethods = require("./bindPublicMethods.cjs");
+const __DEV__ = typeof __MVC_KIT_DEV__ !== "undefined" && __MVC_KIT_DEV__;
+class Pending {
+  // ── Static config (Channel pattern — override via subclass) ──
+  /** Maximum number of retry attempts before marking as failed. */
+  static MAX_RETRIES = 5;
+  /** Base delay (ms) for retry backoff. */
+  static RETRY_BASE = 1e3;
+  /** Maximum delay cap (ms) for retry backoff. */
+  static RETRY_MAX = 3e4;
+  /** Exponential backoff multiplier for retry delay. */
+  static RETRY_FACTOR = 2;
+  // ── Private state ──
+  _operations = /* @__PURE__ */ new Map();
+  _snapshots = /* @__PURE__ */ new Map();
+  _listeners = /* @__PURE__ */ new Set();
+  _disposed = false;
+  _entriesCache = null;
+  constructor() {
+    bindPublicMethods.bindPublicMethods(this);
+  }
+  // ── Readable state (reactive — auto-tracked by ViewModel getters) ──
+  /** Get the frozen status snapshot for an operation by ID, or null if not found. */
+  getStatus(id) {
+    return this._snapshots.get(id) ?? null;
+  }
+  /** Whether an operation exists for the given ID. */
+  has(id) {
+    return this._operations.has(id);
+  }
+  /** Number of operations (all statuses). */
+  get count() {
+    return this._operations.size;
+  }
+  /** Whether any operations are in-flight (active or retrying). */
+  get hasPending() {
+    for (const op of this._operations.values()) {
+      if (op.status !== "failed") return true;
+    }
+    return false;
+  }
+  /** Whether any operations are in a failed state. */
+  get hasFailed() {
+    for (const op of this._operations.values()) {
+      if (op.status === "failed") return true;
+    }
+    return false;
+  }
+  /** Number of operations in a failed state. */
+  get failedCount() {
+    let n = 0;
+    for (const op of this._operations.values()) {
+      if (op.status === "failed") n++;
+    }
+    return n;
+  }
+  /** All operations as a frozen array of entries (id + snapshot). Cached until next mutation. */
+  get entries() {
+    if (this._entriesCache === null) {
+      const result = [];
+      for (const [id, snapshot] of this._snapshots) {
+        result.push(Object.freeze({ ...snapshot, id }));
+      }
+      this._entriesCache = Object.freeze(result);
+    }
+    return this._entriesCache;
+  }
+  // ── Core API ──
+  /**
+   * Enqueue an operation for the given ID. Fire-and-forget (synchronous return).
+   * If the same ID already has a pending operation, it is superseded (aborted).
+   */
+  enqueue(id, operation, execute, meta) {
+    if (this._disposed) {
+      if (__DEV__) {
+        console.warn("[mvc-kit] Pending.enqueue() called after dispose — ignored.");
+      }
+      return;
+    }
+    const existing = this._operations.get(id);
+    if (existing) {
+      existing.abortController.abort();
+      if (existing.retryTimer !== null) {
+        clearTimeout(existing.retryTimer);
+      }
+    }
+    const op = {
+      id,
+      operation,
+      execute,
+      status: "active",
+      attempts: 0,
+      error: null,
+      errorCode: null,
+      nextRetryAt: null,
+      createdAt: Date.now(),
+      abortController: new AbortController(),
+      retryTimer: null,
+      meta: meta ?? null
+    };
+    this._operations.set(id, op);
+    this._snapshot(op);
+    this._notify();
+    queueMicrotask(() => this._process(id));
+  }
+  // ── Controls ──
+  /** Retry a failed operation. No-op if the operation is not in 'failed' status. */
+  retry(id) {
+    if (this._disposed) {
+      if (__DEV__) {
+        console.warn("[mvc-kit] Pending.retry() called after dispose — ignored.");
+      }
+      return;
+    }
+    const op = this._operations.get(id);
+    if (!op || op.status !== "failed") return;
+    op.attempts = 0;
+    op.error = null;
+    op.errorCode = null;
+    op.nextRetryAt = null;
+    op.abortController = new AbortController();
+    this._process(id);
+  }
+  /** Retry all failed operations. */
+  retryAll() {
+    if (this._disposed) {
+      if (__DEV__) {
+        console.warn("[mvc-kit] Pending.retryAll() called after dispose — ignored.");
+      }
+      return;
+    }
+    const failedIds = [];
+    for (const op of this._operations.values()) {
+      if (op.status === "failed") failedIds.push(op.id);
+    }
+    for (const id of failedIds) {
+      this.retry(id);
+    }
+  }
+  /** Cancel an in-flight operation by ID. Aborts the signal, clears timers, and removes it. */
+  cancel(id) {
+    const op = this._operations.get(id);
+    if (!op) return;
+    op.abortController.abort();
+    if (op.retryTimer !== null) {
+      clearTimeout(op.retryTimer);
+    }
+    this._operations.delete(id);
+    this._snapshots.delete(id);
+    this._notify();
+  }
+  /** Cancel all operations. */
+  cancelAll() {
+    for (const op of this._operations.values()) {
+      op.abortController.abort();
+      if (op.retryTimer !== null) {
+        clearTimeout(op.retryTimer);
+      }
+    }
+    this._operations.clear();
+    this._snapshots.clear();
+    if (this._listeners.size > 0) this._notify();
+  }
+  /** Remove a failed operation without retrying. No-op if the operation is not in 'failed' status. */
+  dismiss(id) {
+    const op = this._operations.get(id);
+    if (!op || op.status !== "failed") return;
+    this._operations.delete(id);
+    this._snapshots.delete(id);
+    this._notify();
+  }
+  /** Remove all failed operations without retrying. */
+  dismissAll() {
+    const failedIds = [];
+    for (const op of this._operations.values()) {
+      if (op.status === "failed") failedIds.push(op.id);
+    }
+    if (failedIds.length === 0) return;
+    for (const id of failedIds) {
+      this._operations.delete(id);
+      this._snapshots.delete(id);
+    }
+    this._notify();
+  }
+  // ── Hooks (overridable in subclass) ──
+  /**
+   * Determines whether an error is retryable. Override in a subclass to customize.
+   * Default: retries on network, timeout, and server_error codes.
+   * @protected
+   */
+  isRetryable(error) {
+    const code = errors.classifyError(error).code;
+    return code === "network" || code === "timeout" || code === "server_error";
+  }
+  // ── Subscribable interface (duck-typed — auto-tracked by ViewModel) ──
+  /** Subscribe to state changes. Returns an unsubscribe function. */
+  subscribe(cb) {
+    this._listeners.add(cb);
+    return () => {
+      this._listeners.delete(cb);
+    };
+  }
+  // ── Lifecycle ──
+  /** Whether this instance has been disposed. */
+  get disposed() {
+    return this._disposed;
+  }
+  /** Dispose: cancels all operations, clears listeners. */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this.cancelAll();
+    this._listeners.clear();
+  }
+  // ── Internals ──
+  _snapshot(op) {
+    const ctor = this.constructor;
+    this._snapshots.set(op.id, Object.freeze({
+      status: op.status,
+      operation: op.operation,
+      attempts: op.attempts,
+      maxRetries: ctor.MAX_RETRIES,
+      error: op.error,
+      errorCode: op.errorCode,
+      nextRetryAt: op.nextRetryAt,
+      createdAt: op.createdAt,
+      meta: op.meta
+    }));
+  }
+  _notify() {
+    this._entriesCache = null;
+    for (const cb of this._listeners) cb();
+  }
+  _process(id) {
+    const op = this._operations.get(id);
+    if (!op || this._disposed) return;
+    op.status = "active";
+    op.attempts++;
+    op.error = null;
+    op.errorCode = null;
+    op.nextRetryAt = null;
+    this._snapshot(op);
+    this._notify();
+    op.execute(op.abortController.signal).then(
+      () => {
+        if (this._operations.get(id) !== op) return;
+        const operation = op.operation;
+        this._operations.delete(id);
+        this._snapshots.delete(id);
+        this._notify();
+        this.onConfirmed?.(id, operation);
+      },
+      (error) => {
+        if (this._operations.get(id) !== op) return;
+        if (errors.isAbortError(error)) {
+          this._operations.delete(id);
+          this._snapshots.delete(id);
+          this._notify();
+          return;
+        }
+        const ctor = this.constructor;
+        const classified = errors.classifyError(error);
+        if (this.isRetryable(error) && op.attempts < ctor.MAX_RETRIES) {
+          op.status = "retrying";
+          const delay = this._calculateDelay(op.attempts - 1);
+          op.nextRetryAt = Date.now() + delay;
+          op.error = classified.message;
+          op.errorCode = classified.code;
+          this._snapshot(op);
+          this._notify();
+          op.retryTimer = setTimeout(() => {
+            op.retryTimer = null;
+            this._process(id);
+          }, delay);
+        } else {
+          op.status = "failed";
+          op.error = classified.message;
+          op.errorCode = classified.code;
+          op.nextRetryAt = null;
+          this._snapshot(op);
+          this._notify();
+          this.onFailed?.(id, op.operation, error);
+        }
+      }
+    );
+  }
+  /** Computes retry backoff delay with jitter (Channel formula). @private */
+  _calculateDelay(attempt) {
+    const ctor = this.constructor;
+    const capped = Math.min(
+      ctor.RETRY_BASE * Math.pow(ctor.RETRY_FACTOR, attempt),
+      ctor.RETRY_MAX
+    );
+    return Math.random() * capped;
+  }
+}
+exports.Pending = Pending;
+//# sourceMappingURL=Pending.cjs.map

package/dist/Pending.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pending.cjs","sources":["../src/Pending.ts"],"sourcesContent":["import { classifyError, isAbortError } from './errors';\nimport type { AppError } from './errors';\nimport { bindPublicMethods } from './bindPublicMethods';\n\nconst __DEV__ = typeof __MVC_KIT_DEV__ !== 'undefined' && __MVC_KIT_DEV__;\n\n// ── Types ─────────────────────────────────────────────────────────\n\n/** Frozen snapshot of a single pending operation's state. */\nexport interface PendingOperation<Meta = unknown> {\n  readonly status: 'active' | 'retrying' | 'failed';\n  readonly operation: string;\n  readonly attempts: number;\n  readonly maxRetries: number;\n  readonly error: string | null;\n  readonly errorCode: AppError['code'] | null;\n  readonly nextRetryAt: number | null;\n  readonly createdAt: number;\n  readonly meta: Meta | null;\n}\n\n/** A PendingOperation snapshot paired with its key, for iteration. */\nexport interface PendingEntry<K extends string | number, Meta = unknown>\n  extends PendingOperation<Meta> {\n  readonly id: K;\n}\n\n/** Mutable internal state for a pending operation. */\ninterface InternalOp<K, Meta> {\n  id: K;\n  operation: string;\n  execute: (signal: AbortSignal) => Promise<void>;\n  status: PendingOperation['status'];\n  attempts: number;\n  error: string | null;\n  errorCode: AppError['code'] | null;\n  nextRetryAt: number | null;\n  createdAt: number;\n  abortController: AbortController;\n  retryTimer: ReturnType<typeof setTimeout> | null;\n  meta: Meta | null;\n}\n\n// ── Pending ───────────────────────────────────────────────────────\n\n/**\n * Per-item operation queue with retry and status tracking.\n * Tracks operations by key with exponential backoff retry on transient errors.\n * Subscribable — auto-tracked when used as a ViewModel/Resource property.\n */\nexport class Pending<K extends string | number = string | number, Meta = unknown> {\n  // ── Static config (Channel pattern — override via subclass) ──\n\n  /** Maximum number of retry attempts before marking as failed. */\n  static MAX_RETRIES = 5;\n  /** Base delay (ms) for retry backoff. */\n  static RETRY_BASE = 1000;\n  /** Maximum delay cap (ms) for retry backoff. */\n  static RETRY_MAX = 30000;\n  /** Exponential backoff multiplier for retry delay. */\n  static RETRY_FACTOR = 2;\n\n  // ── Private state ──\n\n  private _operations = new Map<K, InternalOp<K, Meta>>();\n  private _snapshots = new Map<K, PendingOperation<Meta>>();\n  private _listeners = new Set<() => void>();\n  private _disposed = false;\n  private _entriesCache: readonly PendingEntry<K, Meta>[] | null = null;\n\n  constructor() {\n    bindPublicMethods(this);\n  }\n\n  // ── Readable state (reactive — auto-tracked by ViewModel getters) ──\n\n  /** Get the frozen status snapshot for an operation by ID, or null if not found. */\n  getStatus(id: K): PendingOperation<Meta> | null {\n    return this._snapshots.get(id) ?? null;\n  }\n\n  /** Whether an operation exists for the given ID. */\n  has(id: K): boolean {\n    return this._operations.has(id);\n  }\n\n  /** Number of operations (all statuses). */\n  get count(): number {\n    return this._operations.size;\n  }\n\n  /** Whether any operations are in-flight (active or retrying). */\n  get hasPending(): boolean {\n    for (const op of this._operations.values()) {\n      if (op.status !== 'failed') return true;\n    }\n    return false;\n  }\n\n  /** Whether any operations are in a failed state. */\n  get hasFailed(): boolean {\n    for (const op of this._operations.values()) {\n      if (op.status === 'failed') return true;\n    }\n    return false;\n  }\n\n  /** Number of operations in a failed state. */\n  get failedCount(): number {\n    let n = 0;\n    for (const op of this._operations.values()) {\n      if (op.status === 'failed') n++;\n    }\n    return n;\n  }\n\n  /** All operations as a frozen array of entries (id + snapshot). Cached until next mutation. */\n  get entries(): readonly PendingEntry<K, Meta>[] {\n    if (this._entriesCache === null) {\n      const result: PendingEntry<K, Meta>[] = [];\n      for (const [id, snapshot] of this._snapshots) {\n        result.push(Object.freeze({ ...snapshot, id }));\n      }\n      this._entriesCache = Object.freeze(result) as readonly PendingEntry<K, Meta>[];\n    }\n    return this._entriesCache;\n  }\n\n  // ── Core API ──\n\n  /**\n   * Enqueue an operation for the given ID. Fire-and-forget (synchronous return).\n   * If the same ID already has a pending operation, it is superseded (aborted).\n   */\n  enqueue(id: K, operation: string, execute: (signal: AbortSignal) => Promise<void>, meta?: Meta): void {\n    if (this._disposed) {\n      if (__DEV__) {\n        console.warn('[mvc-kit] Pending.enqueue() called after dispose — ignored.');\n      }\n      return;\n    }\n\n    // Supersede existing operation for this ID\n    const existing = this._operations.get(id);\n    if (existing) {\n      existing.abortController.abort();\n      if (existing.retryTimer !== null) {\n        clearTimeout(existing.retryTimer);\n      }\n    }\n\n    const op: InternalOp<K, Meta> = {\n      id,\n      operation,\n      execute,\n      status: 'active',\n      attempts: 0,\n      error: null,\n      errorCode: null,\n      nextRetryAt: null,\n      createdAt: Date.now(),\n      abortController: new AbortController(),\n      retryTimer: null,\n      meta: meta ?? null,\n    };\n\n    this._operations.set(id, op);\n    this._snapshot(op);\n    this._notify();\n\n    // Schedule processing via microtask (allows batching multiple enqueues)\n    queueMicrotask(() => this._process(id));\n  }\n\n  // ── Controls ──\n\n  /** Retry a failed operation. No-op if the operation is not in 'failed' status. */\n  retry(id: K): void {\n    if (this._disposed) {\n      if (__DEV__) {\n        console.warn('[mvc-kit] Pending.retry() called after dispose — ignored.');\n      }\n      return;\n    }\n\n    const op = this._operations.get(id);\n    if (!op || op.status !== 'failed') return;\n\n    op.attempts = 0;\n    op.error = null;\n    op.errorCode = null;\n    op.nextRetryAt = null;\n    op.abortController = new AbortController();\n    this._process(id);\n  }\n\n  /** Retry all failed operations. */\n  retryAll(): void {\n    if (this._disposed) {\n      if (__DEV__) {\n        console.warn('[mvc-kit] Pending.retryAll() called after dispose — ignored.');\n      }\n      return;\n    }\n\n    const failedIds: K[] = [];\n    for (const op of this._operations.values()) {\n      if (op.status === 'failed') failedIds.push(op.id);\n    }\n    for (const id of failedIds) {\n      this.retry(id);\n    }\n  }\n\n  /** Cancel an in-flight operation by ID. Aborts the signal, clears timers, and removes it. */\n  cancel(id: K): void {\n    const op = this._operations.get(id);\n    if (!op) return;\n\n    op.abortController.abort();\n    if (op.retryTimer !== null) {\n      clearTimeout(op.retryTimer);\n    }\n    this._operations.delete(id);\n    this._snapshots.delete(id);\n    this._notify();\n  }\n\n  /** Cancel all operations. */\n  cancelAll(): void {\n    for (const op of this._operations.values()) {\n      op.abortController.abort();\n      if (op.retryTimer !== null) {\n        clearTimeout(op.retryTimer);\n      }\n    }\n    this._operations.clear();\n    this._snapshots.clear();\n    if (this._listeners.size > 0) this._notify();\n  }\n\n  /** Remove a failed operation without retrying. No-op if the operation is not in 'failed' status. */\n  dismiss(id: K): void {\n    const op = this._operations.get(id);\n    if (!op || op.status !== 'failed') return;\n\n    this._operations.delete(id);\n    this._snapshots.delete(id);\n    this._notify();\n  }\n\n  /** Remove all failed operations without retrying. */\n  dismissAll(): void {\n    const failedIds: K[] = [];\n    for (const op of this._operations.values()) {\n      if (op.status === 'failed') failedIds.push(op.id);\n    }\n    if (failedIds.length === 0) return;\n    for (const id of failedIds) {\n      this._operations.delete(id);\n      this._snapshots.delete(id);\n    }\n    this._notify();\n  }\n\n  // ── Hooks (overridable in subclass) ──\n\n  /**\n   * Determines whether an error is retryable. Override in a subclass to customize.\n   * Default: retries on network, timeout, and server_error codes.\n   * @protected\n   */\n  protected isRetryable(error: unknown): boolean {\n    const code = classifyError(error).code;\n    return code === 'network' || code === 'timeout' || code === 'server_error';\n  }\n\n  /** Called when an operation succeeds. Override in a subclass for side effects. @protected */\n  protected onConfirmed?(id: K, operation: string): void;\n  /** Called when an operation fails permanently. Override in a subclass for side effects. @protected */\n  protected onFailed?(id: K, operation: string, error: unknown): void;\n\n  // ── Subscribable interface (duck-typed — auto-tracked by ViewModel) ──\n\n  /** Subscribe to state changes. Returns an unsubscribe function. */\n  subscribe(cb: () => void): () => void {\n    this._listeners.add(cb);\n    return () => { this._listeners.delete(cb); };\n  }\n\n  // ── Lifecycle ──\n\n  /** Whether this instance has been disposed. */\n  get disposed(): boolean {\n    return this._disposed;\n  }\n\n  /** Dispose: cancels all operations, clears listeners. */\n  dispose(): void {\n    if (this._disposed) return;\n    this._disposed = true;\n    this.cancelAll();\n    this._listeners.clear();\n  }\n\n  // ── Internals ──\n\n  private _snapshot(op: InternalOp<K, Meta>): void {\n    const ctor = this.constructor as typeof Pending;\n    this._snapshots.set(op.id, Object.freeze({\n      status: op.status,\n      operation: op.operation,\n      attempts: op.attempts,\n      maxRetries: ctor.MAX_RETRIES,\n      error: op.error,\n      errorCode: op.errorCode,\n      nextRetryAt: op.nextRetryAt,\n      createdAt: op.createdAt,\n      meta: op.meta,\n    }));\n  }\n\n  private _notify(): void {\n    this._entriesCache = null;\n    for (const cb of this._listeners) cb();\n  }\n\n  private _process(id: K): void {\n    const op = this._operations.get(id);\n    if (!op || this._disposed) return;\n\n    // Set active status\n    op.status = 'active';\n    op.attempts++;\n    op.error = null;\n    op.errorCode = null;\n    op.nextRetryAt = null;\n    this._snapshot(op);\n    this._notify();\n\n    op.execute(op.abortController.signal).then(\n      () => {\n        // Identity check: ignore if this op was superseded or cancelled\n        if (this._operations.get(id) !== op) return;\n        const operation = op.operation;\n        this._operations.delete(id);\n        this._snapshots.delete(id);\n        this._notify();\n        this.onConfirmed?.(id, operation);\n      },\n      (error: unknown) => {\n        // Identity check: ignore if this op was superseded or cancelled\n        if (this._operations.get(id) !== op) return;\n\n        // AbortError — remove silently (cancel or supersede)\n        if (isAbortError(error)) {\n          this._operations.delete(id);\n          this._snapshots.delete(id);\n          this._notify();\n          return;\n        }\n\n        const ctor = this.constructor as typeof Pending;\n        const classified = classifyError(error);\n\n        // Check if retryable and under max retries\n        if (this.isRetryable(error) && op.attempts < ctor.MAX_RETRIES) {\n          op.status = 'retrying';\n          const delay = this._calculateDelay(op.attempts - 1);\n          op.nextRetryAt = Date.now() + delay;\n          op.error = classified.message;\n          op.errorCode = classified.code;\n          this._snapshot(op);\n          this._notify();\n\n          op.retryTimer = setTimeout(() => {\n            op.retryTimer = null;\n            this._process(id);\n          }, delay);\n        } else {\n          // Non-retryable or max retries exceeded\n          op.status = 'failed';\n          op.error = classified.message;\n          op.errorCode = classified.code;\n          op.nextRetryAt = null;\n          this._snapshot(op);\n          this._notify();\n          this.onFailed?.(id, op.operation, error);\n        }\n      },\n    );\n  }\n\n  /** Computes retry backoff delay with jitter (Channel formula). @private */\n  private _calculateDelay(attempt: number): number {\n    const ctor = this.constructor as typeof Pending;\n    const capped = Math.min(\n      ctor.RETRY_BASE * Math.pow(ctor.RETRY_FACTOR, attempt),\n      ctor.RETRY_MAX,\n    );\n    return Math.random() * capped;\n  }\n}\n"],"names":["bindPublicMethods","classifyError","isAbortError"],"mappings":"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"}

package/dist/Pending.d.ts

@@ -0,0 +1,91 @@
+import type { AppError } from './errors';
+/** Frozen snapshot of a single pending operation's state. */
+export interface PendingOperation<Meta = unknown> {
+    readonly status: 'active' | 'retrying' | 'failed';
+    readonly operation: string;
+    readonly attempts: number;
+    readonly maxRetries: number;
+    readonly error: string | null;
+    readonly errorCode: AppError['code'] | null;
+    readonly nextRetryAt: number | null;
+    readonly createdAt: number;
+    readonly meta: Meta | null;
+}
+/** A PendingOperation snapshot paired with its key, for iteration. */
+export interface PendingEntry<K extends string | number, Meta = unknown> extends PendingOperation<Meta> {
+    readonly id: K;
+}
+/**
+ * Per-item operation queue with retry and status tracking.
+ * Tracks operations by key with exponential backoff retry on transient errors.
+ * Subscribable — auto-tracked when used as a ViewModel/Resource property.
+ */
+export declare class Pending<K extends string | number = string | number, Meta = unknown> {
+    /** Maximum number of retry attempts before marking as failed. */
+    static MAX_RETRIES: number;
+    /** Base delay (ms) for retry backoff. */
+    static RETRY_BASE: number;
+    /** Maximum delay cap (ms) for retry backoff. */
+    static RETRY_MAX: number;
+    /** Exponential backoff multiplier for retry delay. */
+    static RETRY_FACTOR: number;
+    private _operations;
+    private _snapshots;
+    private _listeners;
+    private _disposed;
+    private _entriesCache;
+    constructor();
+    /** Get the frozen status snapshot for an operation by ID, or null if not found. */
+    getStatus(id: K): PendingOperation<Meta> | null;
+    /** Whether an operation exists for the given ID. */
+    has(id: K): boolean;
+    /** Number of operations (all statuses). */
+    get count(): number;
+    /** Whether any operations are in-flight (active or retrying). */
+    get hasPending(): boolean;
+    /** Whether any operations are in a failed state. */
+    get hasFailed(): boolean;
+    /** Number of operations in a failed state. */
+    get failedCount(): number;
+    /** All operations as a frozen array of entries (id + snapshot). Cached until next mutation. */
+    get entries(): readonly PendingEntry<K, Meta>[];
+    /**
+     * Enqueue an operation for the given ID. Fire-and-forget (synchronous return).
+     * If the same ID already has a pending operation, it is superseded (aborted).
+     */
+    enqueue(id: K, operation: string, execute: (signal: AbortSignal) => Promise<void>, meta?: Meta): void;
+    /** Retry a failed operation. No-op if the operation is not in 'failed' status. */
+    retry(id: K): void;
+    /** Retry all failed operations. */
+    retryAll(): void;
+    /** Cancel an in-flight operation by ID. Aborts the signal, clears timers, and removes it. */
+    cancel(id: K): void;
+    /** Cancel all operations. */
+    cancelAll(): void;
+    /** Remove a failed operation without retrying. No-op if the operation is not in 'failed' status. */
+    dismiss(id: K): void;
+    /** Remove all failed operations without retrying. */
+    dismissAll(): void;
+    /**
+     * Determines whether an error is retryable. Override in a subclass to customize.
+     * Default: retries on network, timeout, and server_error codes.
+     * @protected
+     */
+    protected isRetryable(error: unknown): boolean;
+    /** Called when an operation succeeds. Override in a subclass for side effects. @protected */
+    protected onConfirmed?(id: K, operation: string): void;
+    /** Called when an operation fails permanently. Override in a subclass for side effects. @protected */
+    protected onFailed?(id: K, operation: string, error: unknown): void;
+    /** Subscribe to state changes. Returns an unsubscribe function. */
+    subscribe(cb: () => void): () => void;
+    /** Whether this instance has been disposed. */
+    get disposed(): boolean;
+    /** Dispose: cancels all operations, clears listeners. */
+    dispose(): void;
+    private _snapshot;
+    private _notify;
+    private _process;
+    /** Computes retry backoff delay with jitter (Channel formula). @private */
+    private _calculateDelay;
+}
+//# sourceMappingURL=Pending.d.ts.map

package/dist/Pending.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pending.d.ts","sourceRoot":"","sources":["../src/Pending.ts"],"names":[],"mappings":"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"}