pixivflow 2.19.2 → 2.19.4

package/dist/storage/repositories/SlotRepository.d.ts

@@ -92,6 +92,33 @@ export declare class SlotRepository extends BaseRepository {
      * candidate replacement is a separate explicit operator action (clearCellWork).
      */
     lockCellWork(slotId: string, targetId: string, workId: string, workType: string): SlotItemRecord;
+    /**
+     * Compare-and-set the cell's work binding, with real concurrency semantics.
+     *
+     * `lockCellWork` above only stops *this* process from overwriting an existing
+     * id (COALESCE); it cannot elect a winner between two callers that both read
+     * "no binding". This one can: the write is guarded by `work_id IS NULL OR
+     * work_id = @workId`, so if two workers select A and B at the same instant
+     * exactly one UPDATE lands. The returned record is authoritative — a losing
+     * caller MUST continue with `cell.workId`, never with its own candidate, or
+     * the cell would process a work it does not own.
+     */
+    tryLockCellWork(slotId: string, targetId: string, workId: string, workType: string): {
+        cell: SlotItemRecord;
+        won: boolean;
+    };
+    /**
+     * Roll back a PROVISIONAL binding taken for a work that produced no local
+     * artifact (a candidate that failed while the cell was still unbound).
+     *
+     * Deliberately narrow: it only clears the row while it still holds exactly
+     * `workId` AND is still `selected`. Once the cell moved on (an artifact was
+     * persisted -> delivery_pending/submitted/..., or another writer rebound it)
+     * the release is refused, so it can never erase a committed work identity.
+     * Re-selecting is only ever allowed while nothing was committed — that is what
+     * keeps (slotId,targetId) -> workId stable.
+     */
+    releaseCellWork(slotId: string, targetId: string, workId: string): boolean;
     /** Explicit operator action: forget the locked work so a re-run picks another candidate. */
     clearCellWork(slotId: string, targetId: string): void;
     setCellStatus(slotId: string, targetId: string, status: CellStatus, error?: string): void;

package/dist/storage/repositories/SlotRepository.js

@@ -137,6 +137,51 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             .run({ slotId, targetId, workId, workType });
         return this.getCell(slotId, targetId);
     }
+    /**
+     * Compare-and-set the cell's work binding, with real concurrency semantics.
+     *
+     * `lockCellWork` above only stops *this* process from overwriting an existing
+     * id (COALESCE); it cannot elect a winner between two callers that both read
+     * "no binding". This one can: the write is guarded by `work_id IS NULL OR
+     * work_id = @workId`, so if two workers select A and B at the same instant
+     * exactly one UPDATE lands. The returned record is authoritative — a losing
+     * caller MUST continue with `cell.workId`, never with its own candidate, or
+     * the cell would process a work it does not own.
+     */
+    tryLockCellWork(slotId, targetId, workId, workType) {
+        this.db
+            .prepare(`UPDATE schedule_slot_items
+         SET work_id = @workId,
+             work_type = CASE WHEN work_id IS NULL THEN @workType ELSE work_type END,
+             status = CASE WHEN status = 'pending' THEN 'selected' ELSE status END,
+             attempt_count = CASE WHEN work_id IS NULL THEN attempt_count + 1 ELSE attempt_count END,
+             updated_at = CURRENT_TIMESTAMP
+         WHERE slot_id = @slotId AND target_id = @targetId
+           AND (work_id IS NULL OR work_id = @workId)`)
+            .run({ slotId, targetId, workId, workType });
+        const cell = this.getCell(slotId, targetId);
+        return { cell, won: cell.workId === workId };
+    }
+    /**
+     * Roll back a PROVISIONAL binding taken for a work that produced no local
+     * artifact (a candidate that failed while the cell was still unbound).
+     *
+     * Deliberately narrow: it only clears the row while it still holds exactly
+     * `workId` AND is still `selected`. Once the cell moved on (an artifact was
+     * persisted -> delivery_pending/submitted/..., or another writer rebound it)
+     * the release is refused, so it can never erase a committed work identity.
+     * Re-selecting is only ever allowed while nothing was committed — that is what
+     * keeps (slotId,targetId) -> workId stable.
+     */
+    releaseCellWork(slotId, targetId, workId) {
+        const info = this.db
+            .prepare(`UPDATE schedule_slot_items
+         SET work_id = NULL, status = 'pending', updated_at = CURRENT_TIMESTAMP
+         WHERE slot_id = @slotId AND target_id = @targetId
+           AND work_id = @workId AND status = 'selected'`)
+            .run({ slotId, targetId, workId });
+        return info.changes > 0;
+    }
     /** Explicit operator action: forget the locked work so a re-run picks another candidate. */
     clearCellWork(slotId, targetId) {
         this.db

package/dist/topic/TopicPipeline.js

@@ -123,6 +123,10 @@ class TopicPipeline {
             // A cancellation must not be degraded into "no results for this tag": that
             // would silently continue the cancelled run across the remaining tags.
             (0, errors_1.rethrowIfCancelled)(error, this.signal);
+            // A broken pager contract must not degrade either: reporting "no works
+            // today" would hide the failure and let the run claim success.
+            if (error instanceof errors_1.PaginationError)
+                throw error;
             logger_1.logger.warn('[TopicCollector] search failed tag=' + tag + ' type=' + contentType + ': ' + (error instanceof Error ? error.message : String(error)));
             return [];
         }

package/dist/utils/errors.d.ts

@@ -33,6 +33,15 @@ export declare class NetworkError extends PixivFlowError {
         waitTime?: number;
     });
 }
+/**
+ * The pagination adapter returned a cursor it had already handed back (the same
+ * `next` twice, or a cycle). Re-requesting would repeat the previous page
+ * forever, which is exactly the Attempt 2 fallback-day failure, so the pager
+ * fails deterministically instead of spinning.
+ */
+export declare class PaginationError extends PixivFlowError {
+    constructor(message: string, cause?: Error);
+}
 export declare class DownloadError extends PixivFlowError {
     readonly itemId?: number | undefined;
     readonly itemType?: "illustration" | "novel" | undefined;

package/dist/utils/errors.js

@@ -4,7 +4,7 @@
  * Provides consistent error types and handling patterns across the application
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorRecoveryStrategy = exports.HelpRequest = exports.VersionRequest = exports.OperationCancelledError = exports.DatabaseError = exports.PendingDeliveryError = exports.DownloadError = exports.NetworkError = exports.AuthenticationError = exports.ConfigError = exports.PixivFlowError = exports.PixivTimeoutError = exports.PixivRateLimitError = exports.PixivNotFoundError = exports.PixivNetworkError = exports.PixivHttpError = exports.PixivError = void 0;
+exports.ErrorRecoveryStrategy = exports.HelpRequest = exports.VersionRequest = exports.OperationCancelledError = exports.DatabaseError = exports.PendingDeliveryError = exports.DownloadError = exports.PaginationError = exports.NetworkError = exports.AuthenticationError = exports.ConfigError = exports.PixivFlowError = exports.PixivTimeoutError = exports.PixivRateLimitError = exports.PixivNotFoundError = exports.PixivNetworkError = exports.PixivHttpError = exports.PixivError = void 0;
 exports.isPixivKitError = isPixivKitError;
 exports.toNetworkError = toNetworkError;
 exports.isOperationCancelled = isOperationCancelled;
@@ -92,6 +92,19 @@ class NetworkError extends PixivFlowError {
     }
 }
 exports.NetworkError = NetworkError;
+/**
+ * The pagination adapter returned a cursor it had already handed back (the same
+ * `next` twice, or a cycle). Re-requesting would repeat the previous page
+ * forever, which is exactly the Attempt 2 fallback-day failure, so the pager
+ * fails deterministically instead of spinning.
+ */
+class PaginationError extends PixivFlowError {
+    constructor(message, cause) {
+        super(message, 'PAGINATION_ERROR', undefined, cause);
+        this.name = 'PaginationError';
+    }
+}
+exports.PaginationError = PaginationError;
 class DownloadError extends PixivFlowError {
     itemId;
     itemType;

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUILD = void 0;
 // GENERATED by scripts/write-version.js — do not edit manually.
-exports.BUILD = { version: '2.19.2', commit: '4b6938041a10' };
+exports.BUILD = { version: '2.19.4', commit: 'f331cd4bb164' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

@@ -1,6 +1,6 @@
 {
   "type": "commonjs",
   "name": "pixivflow-webui-backend",
-  "version": "2.19.2",
+  "version": "2.19.4",
   "description": "PixivFlow WebUI Backend - CommonJS module"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixivflow",
-  "version": "2.19.2",
+  "version": "2.19.4",
   "description": "🎨 智能的 Pixiv 自动化下载工具 - 支持批量下载插画和小说、定时任务、Docker部署 | Intelligent Pixiv Automation Downloader with batch download, scheduler, and Docker support",
   "repository": {
     "type": "git",