pixivflow 2.22.1 → 2.24.0

package/dist/commands/SchedulerCommand.js

@@ -12,6 +12,7 @@ const ScheduleTriggerServer_1 = require("../scheduler/ScheduleTriggerServer");
 const SlotCoordinator_1 = require("../scheduler/SlotCoordinator");
 const schedules_1 = require("../scheduler/schedules");
 const scheduler_runtime_1 = require("./scheduler-runtime");
+const RecoveryOutcome_1 = require("../scheduler/RecoveryOutcome");
 const SchedulerIdleLifecycle_1 = require("./SchedulerIdleLifecycle");
 /**
  * Decide whether the authenticated HTTP trigger server should be mounted. It is
@@ -263,9 +264,17 @@ class SchedulerCommand extends Command_1.BaseCommand {
                     recoverStatus: (targetId, requestId) => {
                         const slot = runtime.database.slots.findRecoverySlot(requestId, targetId);
                         const cell = slot && runtime.database.slots.getCell(slot.id, targetId);
-                        return slot && cell
-                            ? { requestId, slotId: slot.id, state: cell.status, slotStatus: slot.status }
-                            : null;
+                        if (!slot || !cell)
+                            return null;
+                        const businessState = (0, RecoveryOutcome_1.recoveryOutcomeFor)(cell);
+                        return {
+                            requestId,
+                            slotId: slot.id,
+                            state: cell.status,
+                            slotStatus: slot.status,
+                            business_state: businessState,
+                            message: (0, RecoveryOutcome_1.recoveryUserMessage)(businessState),
+                        };
                     },
                     status: (scheduleId) => {
                         const cfg = resolveConfig();

package/dist/commands/scheduler-runtime.d.ts

@@ -119,6 +119,35 @@ export interface SchedulerRuntime {
     close(): void;
 }
 export declare function notifyScheduleFailure(config: StandaloneConfig, database: Database, schedule: ScheduleConfig, failure: JobFailure): Promise<void>;
+/**
+ * A `no_candidate` scan that attempted nothing and whose only candidate skips
+ * are `duplicate` is a TRUE dead-end: every candidate the scan surfaced was
+ * already delivered, and nothing was attempted to be widened. Advancing the
+ * fallback stage for this would re-fetch the SAME stale duplicate pool with a
+ * wider bound and burn the whole scheduler budget again (the production bug
+ * that turned an empty day on bot1 into a 30-minute OperationCancelledError).
+ * Terminalise it immediately instead of entering the fallback re-run loop.
+ */
+export interface CandidateExhaustionDiagnostic {
+    stage: 'candidate_selection';
+    result: 'no_candidate';
+    reason: 'duplicate_exhausted' | 'filter_exhausted' | 'no_candidate';
+    searched: number;
+    duplicates: number;
+    filtered: number;
+    attempted: number;
+}
+/**
+ * Structured diagnostic for a terminal `no_candidate`: what the scan surfaced
+ * (`searched`), how many were already-delivered duplicates, how many were
+ * filtered by the run's own rules, and how many were actually attempted.
+ * Emitted as a JSON log so a Mini App can show "当天候选均已投稿" instead of
+ * treating the slot as a system failure.
+ */
+export declare function candidateExhaustionDiagnostic(outcome: Extract<TargetOutcome, {
+    kind: 'no_candidate';
+}>): CandidateExhaustionDiagnostic | null;
+export declare function isDuplicateOnlyDeadEnd(outcome: TargetOutcome): boolean;
 /**
  * Expanded, still-bounded candidate scan bound for one fallback stage
  * (§schedule-recovery). Stage 0 is the primary pass; stage N scans

package/dist/commands/scheduler-runtime.js

@@ -45,6 +45,8 @@ exports.EXECUTION_MODES = void 0;
 exports.withDeliveryMode = withDeliveryMode;
 exports.shouldTerminaliseAbortedSlot = shouldTerminaliseAbortedSlot;
 exports.notifyScheduleFailure = notifyScheduleFailure;
+exports.candidateExhaustionDiagnostic = candidateExhaustionDiagnostic;
+exports.isDuplicateOnlyDeadEnd = isDuplicateOnlyDeadEnd;
 exports.fallbackScanLimit = fallbackScanLimit;
 exports.createSchedulerRuntime = createSchedulerRuntime;
 exports.runWithTimeout = runWithTimeout;
@@ -201,6 +203,44 @@ function buildProxyUrl(network) {
     const auth = proxy.username ? `${proxy.username}:${proxy.password ?? ''}@` : '';
     return `${protocol}://${auth}${proxy.host}:${proxy.port}`;
 }
+/**
+ * Structured diagnostic for a terminal `no_candidate`: what the scan surfaced
+ * (`searched`), how many were already-delivered duplicates, how many were
+ * filtered by the run's own rules, and how many were actually attempted.
+ * Emitted as a JSON log so a Mini App can show "当天候选均已投稿" instead of
+ * treating the slot as a system failure.
+ */
+function candidateExhaustionDiagnostic(outcome) {
+    const scan = outcome.scan;
+    if (!scan)
+        return null;
+    const skipped = scan.skipped;
+    const duplicates = skipped.filter((s) => s.code === 'duplicate').length;
+    const filtered = skipped.filter((s) => s.code !== 'duplicate' && s.code !== 'unavailable').length;
+    const reason = isDuplicateOnlyDeadEnd(outcome)
+        ? 'duplicate_exhausted'
+        : filtered > 0
+            ? 'filter_exhausted'
+            : 'no_candidate';
+    return {
+        stage: 'candidate_selection',
+        result: 'no_candidate',
+        reason,
+        searched: skipped.length,
+        duplicates,
+        filtered,
+        attempted: scan.attempted,
+    };
+}
+function isDuplicateOnlyDeadEnd(outcome) {
+    if (outcome.kind !== 'no_candidate' || !outcome.scan)
+        return false;
+    const s = outcome.scan;
+    return (s.attempted === 0 &&
+        s.outages.length === 0 &&
+        s.skipped.length > 0 &&
+        s.skipped.every((skip) => skip.code === 'duplicate'));
+}
 /**
  * Expanded, still-bounded candidate scan bound for one fallback stage
  * (§schedule-recovery). Stage 0 is the primary pass; stage N scans
@@ -536,13 +576,26 @@ async function createSchedulerRuntime(configPathArg) {
             // an exhausted occurrence reports the true cause — never a generic
             // "target did not complete".
             if (!scheduleSlot.manualRequestId &&
-                (outcome.kind === 'no_candidate' || outcome.kind === 'duplicate') &&
+                (outcome.kind === 'duplicate' ||
+                    (outcome.kind === 'no_candidate' && !isDuplicateOnlyDeadEnd(outcome))) &&
                 coordinator.cellFallbackStage(scheduleSlot.slotId, target.id) < maxFallbackStages - 1) {
                 coordinator.advanceFallback(scheduleSlot.slotId, target.id, outcome.kind === 'duplicate'
                     ? `duplicate candidates (stage ${coordinator.cellFallbackStage(scheduleSlot.slotId, target.id)})`
                     : outcome.reason ?? 'no eligible candidate', maxFallbackStages);
                 return;
             }
+            if (outcome.kind === 'no_candidate') {
+                const diag = candidateExhaustionDiagnostic(outcome);
+                if (diag) {
+                    logger_1.logger.info('candidate_exhaustion', {
+                        schedule_id: scheduleSlot.scheduleId,
+                        slot_id: scheduleSlot.slotId,
+                        bot_id: scheduleSlot.scheduleId?.split('-')[0],
+                        target_id: target.id,
+                        ...diag,
+                    });
+                }
+            }
             coordinator.applyOutcome(scheduleSlot.slotId, target.id, outcome);
             notificationPolicy.noteOutcome(scheduleSlot.slotId, scheduleSlot, schedule, target, outcome);
             if (scheduleSlot.manualRequestId && (outcome.kind === 'no_candidate' || outcome.kind === 'duplicate' ||

package/dist/download/FileService.d.ts

@@ -31,12 +31,22 @@ export interface PixivMetadata {
         name: string;
         is_chinese: boolean;
     };
+    assets?: Array<{
+        marker: string;
+        kind: 'uploadedimage' | 'pixivimage';
+        sourceId: string;
+        url?: string;
+        localPath?: string;
+        status: 'pending' | 'downloaded' | 'failed' | 'unavailable';
+        failureReason?: string;
+    }>;
 }
 export declare class FileService implements IFileService {
     private readonly storage;
     constructor(storage: StorageConfig);
     initialise(): Promise<void>;
     saveImage(buffer: ArrayBuffer, fileName: string, metadata?: FileMetadata): Promise<string>;
+    saveBinary(buffer: ArrayBuffer, fileName: string, directory: string): Promise<string>;
     saveText(content: string, fileName: string, metadata?: FileMetadata): Promise<string>;
     private static readonly MAX_FILENAME_BYTES;
     sanitizeFileName(name: string): string;

package/dist/download/FileService.js

@@ -27,6 +27,12 @@ class FileService {
         await node_fs_1.promises.writeFile(uniquePath, Buffer.from(buffer));
         return uniquePath;
     }
+    async saveBinary(buffer, fileName, directory) {
+        await (0, fs_1.ensureDir)(directory);
+        const uniquePath = await this.findUniquePath(directory, fileName);
+        await node_fs_1.promises.writeFile(uniquePath, Buffer.from(buffer));
+        return uniquePath;
+    }
     async saveText(content, fileName, metadata) {
         const baseDirectory = this.storage.novelDirectory ?? this.storage.downloadDirectory;
         const organizationMode = this.storage.novelOrganization ?? 'flat';

package/dist/download/NovelDownloader.js

@@ -35,7 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NovelDownloader = void 0;
 const logger_1 = require("../logger");
+const node_path_1 = require("node:path");
 const language_detection_1 = require("../utils/language-detection");
+const novelMarkers_1 = require("./novelMarkers");
 const LANGUAGE_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 class NovelDownloader {
     client;
@@ -156,6 +158,33 @@ class NovelDownloader {
             date: detail.create_date ? new Date(detail.create_date) : new Date(),
         };
         const filePath = await this.fileService.saveText(content, fileName, metadata);
+        const assets = typeof textResponse === 'string'
+            ? []
+            : (0, novelMarkers_1.extractNovelAssets)(text, textResponse);
+        const hadImages = assets.length > 0;
+        const pendingAssets = assets.filter((a) => Boolean(a.url));
+        if (pendingAssets.length) {
+            const imagesDir = (0, node_path_1.join)((0, node_path_1.dirname)(filePath), 'images');
+            for (const asset of pendingAssets) {
+                try {
+                    const buffer = await this.client.downloadImage(asset.url);
+                    asset.localPath = await this.fileService.saveBinary(buffer, novelAssetFileName(asset), imagesDir);
+                    asset.status = 'downloaded';
+                }
+                catch (error) {
+                    asset.status = 'failed';
+                    asset.failureReason = error instanceof Error ? error.message : String(error);
+                    logger_1.logger.warn(`Failed to download novel inline image ${asset.sourceId} for novel ${detail.id}`, {
+                        novelId: detail.id,
+                        sourceId: asset.sourceId,
+                        reason: asset.failureReason,
+                    });
+                }
+            }
+            if (hadImages) {
+                logger_1.logger.info(`Novel ${detail.id} inline images: ${assets.filter((a) => a.status === 'downloaded').length}/${assets.length} downloaded`, { novelId: detail.id });
+            }
+        }
         const pixivMetadata = {
             pixiv_id: detail.id,
             title: detail.title,
@@ -181,6 +210,19 @@ class NovelDownloader {
                     },
                 }
                 : {}),
+            ...(assets.length
+                ? {
+                    assets: assets.map((a) => ({
+                        marker: a.marker,
+                        kind: a.kind,
+                        sourceId: a.sourceId,
+                        url: a.url,
+                        localPath: a.localPath,
+                        status: a.status,
+                        failureReason: a.failureReason,
+                    })),
+                }
+                : {}),
         };
         let metadataPath;
         try {
@@ -222,4 +264,18 @@ class NovelDownloader {
     }
 }
 exports.NovelDownloader = NovelDownloader;
+function novelAssetFileName(asset) {
+    let ext = '';
+    try {
+        const pathname = new URL(asset.url).pathname;
+        const last = pathname.split('/').pop() || '';
+        const dot = last.lastIndexOf('.');
+        if (dot >= 0)
+            ext = last.slice(dot);
+    }
+    catch {
+        // fall through: no extension
+    }
+    return `${asset.sourceId}${ext}` || asset.sourceId;
+}
 //# sourceMappingURL=NovelDownloader.js.map

package/dist/download/exec/DownloadExecutor.js

@@ -26,8 +26,11 @@ class DownloadExecutor {
                         itemId: item?.id,
                         ...(contextProvider?.(item, index) ?? {}),
                     };
+                    const itemId = item?.id ?? item?.pixivId ?? String(item);
+                    logger_1.logger.info('download_started', { pixiv_id: itemId, attempt, stage: 'download' });
                     try {
                         const res = await task(item, index);
+                        logger_1.logger.info('download_completed', { pixiv_id: itemId, attempt, stage: 'download' });
                         results[index] = res;
                         break;
                     }
@@ -35,21 +38,27 @@ class DownloadExecutor {
                         onError?.(error, item, index, attempt);
                         const decision = recovery.decide(error, effectiveContext);
                         onDecision?.(decision, { item, index, attempt, error });
+                        const status = error?.status;
+                        const errMsg = error instanceof Error ? error.message : String(error);
                         if (decision.action === 'skip') {
-                            logger_1.logger.warn(`Skipping item at index ${index} after attempt ${attempt}${decision.reason ? `: ${decision.reason}` : ''}`);
+                            logger_1.logger.warn(status ? `download_http_failed` : `download_failed`, {
+                                pixiv_id: itemId, attempt, stage: 'download', http_status: status ?? null, error: errMsg,
+                            });
                             break;
                         }
                         if (decision.action === 'fail') {
+                            logger_1.logger.error(`download_failed`, { pixiv_id: itemId, attempt, stage: 'download', http_status: status ?? null, error: errMsg });
                             throw error instanceof Error ? error : new Error(String(error));
                         }
                         // retry/backoff
                         const delayMs = decision.delayMs ?? 0;
+                        logger_1.logger.warn(`download_retry`, { pixiv_id: itemId, attempt, stage: 'download', http_status: status ?? null, retry_delay_ms: delayMs, error: errMsg });
                         if (delayMs > 0) {
                             await new Promise((resolve) => setTimeout(resolve, delayMs));
                         }
                         attempt += 1;
                         if (attempt > (decision.maxAttempts ?? maxAttempts)) {
-                            logger_1.logger.error(`Max attempts reached for item at index ${index}; failing`);
+                            logger_1.logger.error(`download_failed`, { pixiv_id: itemId, attempt, stage: 'download', http_status: status ?? null, error: errMsg });
                             throw error instanceof Error ? error : new Error(String(error));
                         }
                     }

package/dist/download/handlers/IllustrationTargetHandler.js

@@ -8,6 +8,8 @@ const pixiv_utils_1 = require("../../utils/pixiv-utils");
 const TargetOutcome_1 = require("../../scheduler/TargetOutcome");
 const WorkIdentity_1 = require("../../scheduler/WorkIdentity");
 const target_label_1 = require("../../utils/target-label");
+const observability_1 = require("../../observability");
+const context_1 = require("../../observability/context");
 const DownloadPlanner_1 = require("../plan/DownloadPlanner");
 const deliveryContext_1 = require("./deliveryContext");
 class IllustrationTargetHandler {
@@ -159,6 +161,13 @@ class IllustrationTargetHandler {
     classifyError(error, displayTag, mode, target) {
         const message = error instanceof Error ? error.message : String(error);
         const scan = this.scan ?? undefined;
+        const cls = (0, observability_1.classifySystemError)(error, error.status, 'pixiv_download');
+        (0, observability_1.recordSystemError)(this.database, (0, context_1.targetErrorContext)(target, this.execution, {
+            message,
+            stage: 'pixiv_download',
+            ...cls,
+            trace_id: this.execution?.slotId,
+        }), cls);
         // A hard job-level outage is named as such and is never recorded as a
         // no-candidate business outcome, whatever its message happens to look like.
         const outage = (0, TargetOutcome_1.classifyJobLevelOutage)(error);
@@ -166,6 +175,8 @@ class IllustrationTargetHandler {
         logger_1.logger.error(`Illustration ${mode === 'ranking' ? 'ranking' : 'tag'} ${displayTag} failed`, {
             error: message,
             errorType: error instanceof Error ? error.constructor.name : typeof error,
+            error_type: cls.error_type,
+            retryable: cls.retryable,
             ...(outage ? { jobLevelOutage: outage } : {}),
         });
         if (outage) {
@@ -508,9 +519,13 @@ class IllustrationTargetHandler {
         if (endpoint) {
             errorMessage = `${errorMessage} [URL: ${endpoint}]`;
         }
+        const cls = (0, observability_1.classifySystemError)(error, error.status, 'pixiv_download');
+        (0, observability_1.recordSystemError)(this.database, (0, context_1.targetErrorContext)({ type: 'illustration' }, this.execution, { message: errorMessage, stage: 'pixiv_download', ...cls, trace_id: this.execution?.slotId }), cls);
         logger_1.logger.error(message, {
             error: errorMessage,
             errorType: error instanceof Error ? error.constructor.name : typeof error,
+            error_type: cls.error_type,
+            retryable: cls.retryable,
             stack: error instanceof Error ? error.stack : undefined,
         });
     }

package/dist/download/handlers/NovelTargetHandler.js

@@ -8,6 +8,8 @@ const pixiv_utils_1 = require("../../utils/pixiv-utils");
 const TargetOutcome_1 = require("../../scheduler/TargetOutcome");
 const WorkIdentity_1 = require("../../scheduler/WorkIdentity");
 const target_label_1 = require("../../utils/target-label");
+const observability_1 = require("../../observability");
+const context_1 = require("../../observability/context");
 const DownloadPlanner_1 = require("../plan/DownloadPlanner");
 const deliveryContext_1 = require("./deliveryContext");
 class NovelTargetHandler {
@@ -109,7 +111,7 @@ class NovelTargetHandler {
             return this.summarize();
         }
         catch (error) {
-            return this.classifyError(error, displayTag, mode);
+            return this.classifyError(error, displayTag, mode, target);
         }
     }
     /**
@@ -165,15 +167,19 @@ class NovelTargetHandler {
             ...(scan ? { scan } : {}),
         };
     }
-    classifyError(error, displayTag, mode) {
+    classifyError(error, displayTag, mode, target) {
         const message = error instanceof Error ? error.message : String(error);
         const scan = this.scan ?? undefined;
+        const cls = (0, observability_1.classifySystemError)(error, error.status, 'pixiv_download');
+        (0, observability_1.recordSystemError)(this.database, (0, context_1.targetErrorContext)(target, this.execution, { message, stage: 'pixiv_download', ...cls, trace_id: this.execution?.slotId }), cls);
         // A hard job-level outage is named as such and is never recorded as a
         // no-candidate business outcome, whatever its message happens to look like.
         const outage = (0, TargetOutcome_1.classifyJobLevelOutage)(error);
         this.database.logExecution(displayTag, 'novel', 'failed', message);
         logger_1.logger.error(`Novel ${mode === 'ranking' ? 'ranking' : 'tag'} ${displayTag} failed`, {
             error: message,
+            error_type: cls.error_type,
+            retryable: cls.retryable,
             ...(outage ? { jobLevelOutage: outage } : {}),
         });
         if (outage) {
@@ -535,9 +541,13 @@ class NovelTargetHandler {
         if (endpoint) {
             errorMessage = `${errorMessage} [URL: ${endpoint}]`;
         }
+        const cls = (0, observability_1.classifySystemError)(error, error.status, 'pixiv_download');
+        (0, observability_1.recordSystemError)(this.database, (0, context_1.targetErrorContext)({ type: 'novel' }, this.execution, { message: errorMessage, stage: 'pixiv_download', ...cls, trace_id: this.execution?.slotId }), cls);
         logger_1.logger.error(message, {
             error: errorMessage,
             errorType: error instanceof Error ? error.constructor.name : typeof error,
+            error_type: cls.error_type,
+            retryable: cls.retryable,
             stack: error instanceof Error ? error.stack : undefined,
         });
     }

package/dist/download/novelMarkers.d.ts

@@ -0,0 +1,54 @@
+import type { PixivNovelTextResponse } from '@redtidev/pixiv-client';
+/**
+ * Single-pass novel text tokenizer, ported from PixEz
+ * (Notsfsssf/pixez-flutter lib/page/novel/viewer/image_text.dart,
+ * NovelSpansGenerator.buildSpans). Same endpoint + same extraction path as
+ * PixivFlow's webview fallback; keeps the `[[...]]` double-bracket close rule so
+ * URLs/etc. inside jumpuri/ruby markers are not truncated early.
+ */
+export type NovelMarker = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'newpage';
+    raw: string;
+} | {
+    type: 'chapter';
+    raw: string;
+    title: string;
+} | {
+    type: 'pixivimage';
+    raw: string;
+    key: string;
+} | {
+    type: 'uploadedimage';
+    raw: string;
+    key: string;
+} | {
+    type: 'jumpuri';
+    raw: string;
+    url?: string;
+} | {
+    type: 'ruby';
+    raw: string;
+    reading: string;
+};
+export interface NovelAsset {
+    marker: string;
+    kind: 'uploadedimage' | 'pixivimage';
+    sourceId: string;
+    url?: string;
+    localPath?: string;
+    status: 'pending' | 'downloaded' | 'failed' | 'unavailable';
+    failureReason?: string;
+}
+export declare function scanNovelMarkers(source: string): NovelMarker[];
+/**
+ * Build the ordered set of inline image assets referenced by the novel text.
+ * `unavailable` = the source is missing in the webview payload (deleted/no
+ * permission) so it will never succeed; `pending` = resolvable + downloadable.
+ */
+export declare function extractNovelAssets(text: string, response?: Pick<PixivNovelTextResponse, 'images' | 'illusts'>): NovelAsset[];
+/** Minimal self-check for the scanner's double-bracket handling. */
+export declare function demo(): void;
+//# sourceMappingURL=novelMarkers.d.ts.map

package/dist/download/novelMarkers.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanNovelMarkers = scanNovelMarkers;
+exports.extractNovelAssets = extractNovelAssets;
+exports.demo = demo;
+const linkRegex = /https?:\/\/\S+/;
+function parseMarker(span) {
+    if (span.startsWith('[newpage]'))
+        return { type: 'newpage', raw: span };
+    if (span.startsWith('[chapter:')) {
+        return { type: 'chapter', raw: span, title: span.slice('[chapter:'.length, -1) };
+    }
+    if (span.startsWith('[pixivimage:')) {
+        return { type: 'pixivimage', raw: span, key: span.slice('[pixivimage:'.length, -1) };
+    }
+    if (span.startsWith('[uploadedimage:')) {
+        return { type: 'uploadedimage', raw: span, key: span.slice('[uploadedimage:'.length, -1) };
+    }
+    if (span.startsWith('[[jumpuri:')) {
+        const body = span.slice('[[jumpuri:'.length, span.endsWith(']]') ? -2 : -1);
+        return { type: 'jumpuri', raw: span, url: body.match(linkRegex)?.[0] };
+    }
+    if (span.startsWith('[[rb:')) {
+        const reading = span.slice('[[rb:'.length, span.endsWith(']]') ? -2 : -1);
+        return { type: 'ruby', raw: span, reading };
+    }
+    return { type: 'text', value: span };
+}
+function scanNovelMarkers(source) {
+    const result = [];
+    let now = '';
+    for (const ch of source) {
+        if (ch === '[') {
+            if (!now) {
+                now = ch;
+            }
+            else if (now === '[') {
+                now += ch;
+            }
+            else {
+                result.push(parseMarker(now));
+                now = ch;
+            }
+        }
+        else if (ch === ']') {
+            if (now.startsWith('[[')) {
+                if (now.endsWith(']')) {
+                    now += ch;
+                    result.push(parseMarker(now));
+                    now = '';
+                }
+                else {
+                    now += ch;
+                }
+            }
+            else {
+                now += ch;
+                result.push(parseMarker(now));
+                now = '';
+            }
+        }
+        else {
+            now += ch;
+        }
+    }
+    if (now)
+        result.push(parseMarker(now));
+    return result;
+}
+function uploadedImageUrl(img) {
+    if (!img?.urls)
+        return undefined;
+    return img.urls.original ?? img.urls.the1200X1200 ?? img.urls.the480Mw ?? img.urls.the240Mw ?? img.urls.the128X128;
+}
+function illustImageUrl(ref) {
+    if (!ref?.illust?.images)
+        return undefined;
+    return ref.illust.images.original ?? ref.illust.images.medium ?? ref.illust.images.small;
+}
+/**
+ * Build the ordered set of inline image assets referenced by the novel text.
+ * `unavailable` = the source is missing in the webview payload (deleted/no
+ * permission) so it will never succeed; `pending` = resolvable + downloadable.
+ */
+function extractNovelAssets(text, response) {
+    const assets = [];
+    for (const marker of scanNovelMarkers(text)) {
+        if (marker.type === 'uploadedimage') {
+            const url = uploadedImageUrl(response?.images?.[marker.key]);
+            assets.push({
+                marker: marker.raw,
+                kind: 'uploadedimage',
+                sourceId: marker.key,
+                url,
+                status: url ? 'pending' : 'unavailable',
+            });
+        }
+        else if (marker.type === 'pixivimage') {
+            const url = illustImageUrl(response?.illusts?.[marker.key]);
+            assets.push({
+                marker: marker.raw,
+                kind: 'pixivimage',
+                sourceId: marker.key,
+                url,
+                status: url ? 'pending' : 'unavailable',
+            });
+        }
+    }
+    return assets;
+}
+/** Minimal self-check for the scanner's double-bracket handling. */
+function demo() {
+    const { assert } = require('node:assert');
+    for (const s of [
+        'before [uploadedimage:11] after',
+        '[[jumpuri:Title > https://example.com/a]] tail',
+        'mixed [pixivimage:12551-1] and [[rb:漢字>かな]] done',
+    ]) {
+        assert(Array.isArray(scanNovelMarkers(s)) && scanNovelMarkers(s).length > 0, 'markers parsed');
+    }
+}
+//# sourceMappingURL=novelMarkers.js.map

package/dist/interfaces/IDatabase.d.ts

@@ -112,5 +112,16 @@ export interface IDatabase {
      * Update file path in database
      */
     updateFilePath(pixivId: string, type: 'illustration' | 'novel', oldPath: string, newPath: string): number;
+    /**
+     * Durable system-error ledger (observability; never throws).
+     */
+    readonly systemErrors: {
+        record(input: import('../observability/types').SystemErrorInput): void;
+        list(opts?: Record<string, unknown>): import('../observability/types').SystemErrorRow[];
+        markResolved(id: number): {
+            changes: number;
+        };
+        countSince(botId: string | null, hours: number): number;
+    };
 }
 //# sourceMappingURL=IDatabase.d.ts.map

package/dist/interfaces/IFileService.d.ts

@@ -16,6 +16,10 @@ export interface IFileService {
      * Save text file (novel)
      */
     saveText(content: string, fileName: string, metadata?: FileMetadata): Promise<string>;
+    /**
+     * Save a binary asset into an explicit directory (e.g. novel inline images).
+     */
+    saveBinary(buffer: ArrayBuffer, fileName: string, directory: string): Promise<string>;
     /**
      * Sanitize file name
      */

package/dist/logger.d.ts

@@ -1,18 +1,42 @@
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type LogFormat = 'text' | 'json';
+export interface LogContext {
+    service?: string;
+    component?: string;
+    bot_id?: string;
+    schedule_id?: string;
+    slot_id?: string;
+    pixiv_id?: string;
+    stage?: string;
+    trace_id?: string;
+    [key: string]: unknown;
+}
 interface LogMeta {
     [key: string]: unknown;
 }
 declare class Logger {
     private static readonly levelOrder;
     private threshold;
+    private format;
     private logPath;
     setLevel(level: LogLevel): void;
+    setFormat(format: LogFormat): void;
+    /** Run `fn` with a log context that is merged into every log line emitted inside. */
+    runWithContext<T>(ctx: LogContext, fn: () => T): T;
     setLogPath(path: string): void;
     debug(message: string, meta?: LogMeta): void;
     info(message: string, meta?: LogMeta): void;
     warn(message: string, meta?: LogMeta): void;
     error(message: string, meta?: LogMeta): void;
     private write;
+    /**
+     * Rotate the current log file when it exceeds the size cap:
+     * rename to <name>-<ts>.log.gz, then prune archived logs older than
+     * retention days. Run inside write (low-traffic scheduler, acceptable;
+     * use a background job if this ever becomes a high-rate service).
+     */
+    private rotateIfNeeded;
+    private pruneArchives;
 }
 export declare const logger: Logger;
 export {};