target-supabase-sdk 0.2.17 → 0.2.19

package/dist/node.js

@@ -1,14 +1,15 @@
 import { z } from 'zod';
-import { M as MAX_POLL_TARGET_LIST_SIZE, V as validateWithSchema, g as createLogger, z as pollTargetList, k as generateResponse, h as createTarget, K as supabase, w as logManager, X as createScope, d as LogLevel, Y as patchScope, J as scanTargetList, Z as withModule, l as getPossibleTarget, E as postTarget, q as isCreateTargetAlreadyExistsError, t as isOptimisticLockResponse, R as updateTargetDetails } from './chunks/list.api-BzbTJBsM.js';
-export { B as BaseValidator, C as CREATE_TARGET_ALREADY_EXISTS_MESSAGE, a as CategoryList, L as LOG_BATCH_LOADER_KEY, b as LOG_MIN_LEVEL_ENV_KEY, c as LOG_PERSIST_LOADER_KEY, e as MAX_TARGET_LIST_PAGE_SIZE, O as OPTIMISTIC_LOCK_ERROR_CODE, f as OPTIMISTIC_LOCK_FAILED_MESSAGE, P as PostListValidator, S as StatusCode, U as UPDATE_TARGET_NOT_FOUND_MESSAGE, i as deleteTarget, j as formatZodError, m as getTarget, n as getTargetList, o as getTargetTotalCount, p as handleSupabaseError, r as isDevEnvironment, s as isOptimisticLockError, u as logDev, v as logDevGroup, x as logMinLevelFromEnv, y as patchTarget, A as postListCreate, D as postLogListCreate, F as postTargetPayloadSchema, G as queryFilterSchema, H as resolveLogMinLevel, I as safeParseWithSchema, N as targetDraftSchema, Q as updateTarget, T as validateWith } from './chunks/list.api-BzbTJBsM.js';
+import { M as MAX_POLL_TARGET_LIST_SIZE, V as validateWithSchema, g as createLogger, z as pollTargetList, k as generateResponse, h as createTarget, K as supabase, w as logManager, X as createScope, d as LogLevel, Y as patchScope, J as scanTargetList, Z as withModule, l as getPossibleTarget, m as getTarget, Q as updateTarget, E as postTarget, q as isCreateTargetAlreadyExistsError, t as isOptimisticLockResponse, R as updateTargetDetails } from './chunks/list.api-BzbTJBsM.js';
+export { B as BaseValidator, C as CREATE_TARGET_ALREADY_EXISTS_MESSAGE, a as CategoryList, L as LOG_BATCH_LOADER_KEY, b as LOG_MIN_LEVEL_ENV_KEY, c as LOG_PERSIST_LOADER_KEY, e as MAX_TARGET_LIST_PAGE_SIZE, O as OPTIMISTIC_LOCK_ERROR_CODE, f as OPTIMISTIC_LOCK_FAILED_MESSAGE, P as PostListValidator, S as StatusCode, U as UPDATE_TARGET_NOT_FOUND_MESSAGE, i as deleteTarget, j as formatZodError, n as getTargetList, o as getTargetTotalCount, p as handleSupabaseError, r as isDevEnvironment, s as isOptimisticLockError, u as logDev, v as logDevGroup, x as logMinLevelFromEnv, y as patchTarget, A as postListCreate, D as postLogListCreate, F as postTargetPayloadSchema, G as queryFilterSchema, H as resolveLogMinLevel, I as safeParseWithSchema, N as targetDraftSchema, T as validateWith } from './chunks/list.api-BzbTJBsM.js';
 import { l as loadEnvFiles, b as readEnv, c as requireEnv, d as resolveLogSpoolSpawnEnvForLabel, e as resolveLogSpoolConfig, f as resolveLogSpoolRoot, g as resolveAllLogSpoolProcessRoles, h as logSpoolProcessDir, s as spoolLogger, i as parseLogSpoolBatchFilename, j as computeLogBatchIdempotencyKey, k as buildLogListDraft, n as postLogBatch, a as logSpoolEnabledFromEnv, o as logSpoolConfigFromEnv, L as LOG_SPOOL_SERVICE_ID_ENV, q as ensureLogSpoolFromEnv, t as shutdownLogSpoolFromEnv, u as getLogSpoolStats } from './chunks/enable-C7lFooTG.js';
 export { C as CLI_PROD_FLAG, S as SERVICE_ENV_PROFILE_ENV_KEY, w as SERVICE_ENV_PROFILE_PROD, x as buildLogSpoolSpawnEnv, y as envBool, z as envInt, A as envMs, B as envNumber, D as envPort, E as envProfileFromProcess, F as resolveDefaultEnvFiles, r as resolveProjectRootByPackageName, G as resolveProjectRootFromModule, v as validateLogSpoolPreloadEnv } from './chunks/enable-C7lFooTG.js';
 import { randomBytes, createHash } from 'node:crypto';
 import { readFile, unlink, mkdir, writeFile, rename, access, stat, readdir, constants } from 'node:fs/promises';
 import { dirname, resolve, join, isAbsolute } from 'node:path';
-import { bq as sha256Hex, bw as getErrorMessage, bx as LOG_TOPIC_NODE, aU as postRegisterNode, ay as patchChangeNodeStatus, N as NodeStatus, aJ as patchStopNode, aG as patchNodeHeartBeat, E as EMPTY_REGISTRY_SLOT_RUNTIME_STATE, bg as runRegistrySlotGuardCheck, b6 as registrySlotRuntimePatchFromGuardResult, c as CategoryNode, Z as evaluateBusyNodeLiveness, aI as patchServiceRuntime, an as isLogEntry, F as claimServiceRegistrySlot, m as ServiceRegistryError, e as CategoryRepo, ai as guessMediaMime, M as MEDIA_CONTENT_HASH_ALGORITHM, ao as isMediaValue, as as mediaLinkDedupFilters, y as buildMediaLinkDraft, R as ResultCode, by as LOG_TOPIC_TASK, o as TASK_REPO_USAGE, ac as getScanRemoteRepoValues, aC as patchClaimTask, bz as CRITICAL_UNKNOWN_TASK_TRACE_ID, aA as patchChangeTaskStatus, q as TaskStatusAction, bA as toError, b0 as postTaskSchema, bB as createTaskRow, p as TaskStatus } from './chunks/task-queue-DufG7PlX.js';
-export { A as ApiMethod, C as CategoryConfig, a as CategoryExtraction, b as CategoryLink, d as CategoryParcel, f as CategoryService, g as CategoryTask, D as DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS, L as LINK_MANIFEST_VERSION, h as LIST_MANIFEST_VERSION, i as MEDIA_CONTENT_HASH_PREFIX_LENGTH, j as MEDIA_VALUES, P as POST_TASK_DEFAULT_MAX_ATTEMPTS, k as ParcelManager, l as PostLinkValidator, S as ServiceLifecycleStatus, n as ServiceSlotStatus, T as TARGET_SYSTEM_REGISTRY_KEY, r as apiDetailsSchema, s as appendSystemRegistryEmptySlots, t as assertRegistrySlotAvailable, u as assertRegistrySlotOwner, v as buildEmptyServiceSlots, w as buildLinkTargetDraft, x as buildListTargetDraft, z as buildMediaNameFromLocator, B as buildSystemRegistryConfigDetails, G as classifyNetworkError, H as countTasksByType, I as createActiveServiceLifecycle, J as createClaimedRegistrySlotRuntimeState, K as createStorageProviderRegistry, O as createUploadTracker, Q as decodeLogBatch, U as decodeLogBatchList, V as defaultL3ServiceDetails, W as deleteParcel, X as deleteParcelSchema, Y as escapeIlikePattern, _ as fetchBinaryWithRetry, $ as fetchWithRetry, a0 as fieldDefinitionSchema, a1 as flattenLogBatch, a2 as flattenLogBatches, a3 as formatNetworkError, a4 as getApi, a5 as getApiSchema, a6 as getConfig, a7 as getConfigSchema, a8 as getExtraction, a9 as getExtractionSchema, aa as getParcel, ab as getParcelSchema, ad as getScanRemoteRepoValuesSchema, ae as getService, af as getServiceSchema, ag as getTargetSystemRegistry, ah as getValueAtPath, aj as installChunkFetchRegistry, ak as isHttpUrl, al as isLocalFilesystemPath, am as isLogBatchList, ap as isOpaqueChunkUrl, aq as isRetryableHttpStatus, ar as linkTargetDraftBuildInputSchema, at as parcelDetailsSchema, au as parseLogBatchMeta, av as parseProviderPrefixedUrl, aw as parseServiceSlot, ax as parseServiceSlots, az as patchChangeNodeStatusSchema, aB as patchChangeTaskStatusSchema, aD as patchClaimTaskSchema, aE as patchExtractionObjects, aF as patchExtractionObjectsSchema, aH as patchNodeHeartBeatSchema, aK as patchStopNodeSchema, aL as patchTaskProgress, aM as patchTaskProgressSchema, aN as postApi, aO as postApiSchema, aP as postExtraction, aQ as postExtractionSchema, aR as postLinkCreate, aS as postParcel, aT as postParcelSchema, aV as postRegisterNodeSchema, aW as postService, aX as postServiceInstance, aY as postServiceSchema, aZ as postSystemRegistryConfig, a_ as postSystemRegistryConfigSchema, a$ as postTask, b1 as postTaskWithRetry, b2 as publishParcel, b3 as registerProviderChunkResolver, b4 as registerService, b5 as registerServiceAtStartup, b7 as releaseSystemRegistrySlots, b8 as releaseSystemRegistrySlotsByServiceId, b9 as requestHasBody, ba as resetSystemRegistryConfig, bb as resetSystemRegistryConfigSchema, bc as resolveActiveRegistryServiceId, bd as resolveFetchUrl, be as restoreParcel, bf as restoreParcelById, bh as sanitizeFileName, bi as sanitizeParcelFileName, bj as scanExtractionList, bk as scanExtractionListSchema, bl as schemaDefinitionSchema, bm as serviceDetailsSchema, bn as serviceLifecycleSchema, bo as serviceNodeSnapshotSchema, bp as serviceRuntimeSchema, br as summarizeTaskQueue, bs as systemRegistrySeedSlotSchema, bt as toPostgrestTextArrayLiteral, bu as unregisterService, bv as unregisterServiceAtShutdown } from './chunks/task-queue-DufG7PlX.js';
+import { bv as sha256Hex, bB as getErrorMessage, bC as LOG_TOPIC_NODE, aZ as postRegisterNode, aD as patchChangeNodeStatus, N as NodeStatus, aO as patchStopNode, aL as patchNodeHeartBeat, E as EMPTY_REGISTRY_SLOT_RUNTIME_STATE, bl as runRegistrySlotGuardCheck, bb as registrySlotRuntimePatchFromGuardResult, c as CategoryNode, a0 as evaluateBusyNodeLiveness, aN as patchServiceRuntime, as as isLogEntry, I as claimServiceRegistrySlot, m as ServiceRegistryError, a3 as fetchWithRetry, av as isRetryableHttpStatus, a2 as fetchBinaryWithRetry, au as isOpaqueChunkUrl, e as CategoryRepo, ap as isHttpUrl, bD as isFeedIngestSource, bE as resolveFeedOriginalStorageProvider, b as CategoryLink, bF as buildFeedTagList, ao as isFeedValue, am as guessMediaMime, M as MEDIA_CONTENT_HASH_ALGORITHM, at as isMediaValue, ax as mediaLinkDedupFilters, B as buildMediaLinkDraft, R as ResultCode, bG as LOG_TOPIC_TASK, o as TASK_REPO_USAGE, ag as getScanRemoteRepoValues, aH as patchClaimTask, bH as CRITICAL_UNKNOWN_TASK_TRACE_ID, aF as patchChangeTaskStatus, q as TaskStatusAction, bI as toError, b5 as postTaskSchema, bJ as createTaskRow, p as TaskStatus } from './chunks/task-queue-CUa40Vb5.js';
+export { A as ApiMethod, C as CategoryConfig, a as CategoryExtraction, d as CategoryParcel, f as CategoryService, g as CategoryTask, D as DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS, bK as FEED_INGEST_SOURCES, F as FEED_VALUES, L as LINK_MANIFEST_VERSION, h as LIST_MANIFEST_VERSION, i as MEDIA_CONTENT_HASH_PREFIX_LENGTH, j as MEDIA_VALUES, P as POST_TASK_DEFAULT_MAX_ATTEMPTS, k as ParcelManager, l as PostLinkValidator, S as ServiceLifecycleStatus, n as ServiceSlotStatus, T as TARGET_SYSTEM_REGISTRY_KEY, r as apiDetailsSchema, s as appendSystemRegistryEmptySlots, t as assertRegistrySlotAvailable, u as assertRegistrySlotOwner, v as buildEmptyServiceSlots, w as buildFeedLinkDraft, x as buildFeedLinkName, y as buildLinkTargetDraft, z as buildListTargetDraft, G as buildMediaNameFromLocator, H as buildSystemRegistryConfigDetails, J as classifyNetworkError, K as countTasksByType, O as createActiveServiceLifecycle, Q as createClaimedRegistrySlotRuntimeState, U as createStorageProviderRegistry, V as createUploadTracker, W as decodeLogBatch, X as decodeLogBatchList, Y as defaultL3ServiceDetails, Z as deleteParcel, _ as deleteParcelSchema, $ as escapeIlikePattern, a1 as feedLinkDedupFilters, a4 as fieldDefinitionSchema, a5 as flattenLogBatch, a6 as flattenLogBatches, a7 as formatNetworkError, a8 as getApi, a9 as getApiSchema, aa as getConfig, ab as getConfigSchema, ac as getExtraction, ad as getExtractionSchema, ae as getParcel, af as getParcelSchema, ah as getScanRemoteRepoValuesSchema, ai as getService, aj as getServiceSchema, ak as getTargetSystemRegistry, al as getValueAtPath, an as installChunkFetchRegistry, aq as isLocalFilesystemPath, ar as isLogBatchList, aw as linkTargetDraftBuildInputSchema, ay as parcelDetailsSchema, az as parseLogBatchMeta, aA as parseProviderPrefixedUrl, aB as parseServiceSlot, aC as parseServiceSlots, aE as patchChangeNodeStatusSchema, aG as patchChangeTaskStatusSchema, aI as patchClaimTaskSchema, aJ as patchExtractionObjects, aK as patchExtractionObjectsSchema, aM as patchNodeHeartBeatSchema, aP as patchStopNodeSchema, aQ as patchTaskProgress, aR as patchTaskProgressSchema, aS as postApi, aT as postApiSchema, aU as postExtraction, aV as postExtractionSchema, aW as postLinkCreate, aX as postParcel, aY as postParcelSchema, a_ as postRegisterNodeSchema, a$ as postService, b0 as postServiceInstance, b1 as postServiceSchema, b2 as postSystemRegistryConfig, b3 as postSystemRegistryConfigSchema, b4 as postTask, b6 as postTaskWithRetry, b7 as publishParcel, b8 as registerProviderChunkResolver, b9 as registerService, ba as registerServiceAtStartup, bc as releaseSystemRegistrySlots, bd as releaseSystemRegistrySlotsByServiceId, be as requestHasBody, bf as resetSystemRegistryConfig, bg as resetSystemRegistryConfigSchema, bh as resolveActiveRegistryServiceId, bi as resolveFetchUrl, bj as restoreParcel, bk as restoreParcelById, bm as sanitizeFileName, bn as sanitizeParcelFileName, bo as scanExtractionList, bp as scanExtractionListSchema, bq as schemaDefinitionSchema, br as serviceDetailsSchema, bs as serviceLifecycleSchema, bt as serviceNodeSnapshotSchema, bu as serviceRuntimeSchema, bw as summarizeTaskQueue, bx as systemRegistrySeedSlotSchema, by as toPostgrestTextArrayLiteral, bz as unregisterService, bA as unregisterServiceAtShutdown } from './chunks/task-queue-CUa40Vb5.js';
 import { spawn } from 'node:child_process';
+import { ProxyAgent } from 'undici';
 import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { createReadStream } from 'node:fs';
@@ -923,7 +924,7 @@ function createManagedChildProcesses(options) {
     });
 }
 
-function sleep(ms) {
+function sleep$1(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
@@ -937,7 +938,7 @@ async function pollUntil(options) {
         if (await options.until()) {
             return;
         }
-        await sleep(intervalMs);
+        await sleep$1(intervalMs);
     }
     throw new Error(`pollUntil timeout after ${options.timeoutMs}ms`);
 }
@@ -2611,6 +2612,295 @@ async function runSingleProcessService(options) {
     }
 }
 
+const logger$2 = createLogger({ module: "telegram" });
+let cachedDispatcher;
+let cachedProxyUrl;
+/** Per-request undici dispatcher when proxyUrl is set (Supabase stays direct). */
+function telegramFetchDispatcher(proxyUrl) {
+    if (proxyUrl == null) {
+        return undefined;
+    }
+    if (cachedDispatcher != null && cachedProxyUrl === proxyUrl) {
+        return cachedDispatcher;
+    }
+    cachedDispatcher = new ProxyAgent(proxyUrl);
+    cachedProxyUrl = proxyUrl;
+    return cachedDispatcher;
+}
+function telegramNetworkHint(proxyUrl) {
+    return proxyUrl
+        ? ` (proxy=${proxyUrl}, ensure Clash/V2Ray is running)`
+        : " (set proxyUrl / TELEGRAM_PROXY if api.telegram.org is blocked)";
+}
+function botApiUrl(options, method) {
+    return `${options.apiBaseUrl}/bot${options.botToken}/${method}`;
+}
+function telegramFileDownloadUrl(options, filePath) {
+    const normalized = filePath.replace(/^\/+/, "");
+    return `${options.apiBaseUrl}/file/bot${options.botToken}/${normalized}`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function telegramBackoff(attempt, retryBaseMs) {
+    return sleep(retryBaseMs * 2 ** (attempt - 1));
+}
+/** Bot API JSON call — transport retry via SDK fetch; outer loop retries Telegram `{ ok: false }`. */
+async function callTelegramApi(options, method, initOrFactory, callOptions = {}) {
+    const timeoutMs = callOptions.timeoutMs ?? options.fetchTimeoutMs;
+    const maxAttempts = callOptions.retryAttempts ?? 1;
+    const retryBaseMs = callOptions.retryBaseMs ?? options.uploadRetryBaseMs;
+    const url = botApiUrl(options, method);
+    const label = `Telegram ${method}`;
+    const dispatcher = telegramFetchDispatcher(options.proxyUrl);
+    const hint = telegramNetworkHint(options.proxyUrl);
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const response = await fetchWithRetry(url, initOrFactory, {
+            label,
+            timeoutMs,
+            maxAttempts: attempt === 1 ? maxAttempts : 1,
+            retryBaseMs,
+            dispatcher,
+            hint,
+            logger: logger$2,
+        });
+        let payload;
+        try {
+            payload = (await response.json());
+        }
+        catch {
+            lastError = new Error(`${label}: invalid JSON response (HTTP ${response.status})`);
+            if (attempt < maxAttempts && isRetryableHttpStatus(response.status)) {
+                await telegramBackoff(attempt, retryBaseMs);
+                continue;
+            }
+            throw lastError;
+        }
+        if (!payload.ok) {
+            const description = payload.description ?? `HTTP ${response.status}`;
+            lastError = new Error(`${label}: ${description}`);
+            if (attempt < maxAttempts && isRetryableHttpStatus(response.status)) {
+                logger$2.warn("retrying after API error", {
+                    topic: "telegram",
+                    data: { method, attempt, description },
+                });
+                await telegramBackoff(attempt, retryBaseMs);
+                continue;
+            }
+            throw lastError;
+        }
+        if (payload.result == null) {
+            throw new Error(`${label}: empty result in response`);
+        }
+        if (attempt > 1) {
+            logger$2.info("request succeeded after retry", { topic: "telegram", data: { method, attempt } });
+        }
+        return payload.result;
+    }
+    throw lastError ?? new Error(`${label}: request failed`);
+}
+async function telegramDownloadBinary(options, url, label, callOptions = {}) {
+    const dispatcher = telegramFetchDispatcher(options.proxyUrl);
+    return fetchBinaryWithRetry(url, { method: "GET" }, {
+        label: `Telegram ${label}`,
+        timeoutMs: callOptions.timeoutMs ?? options.fetchTimeoutMs,
+        maxAttempts: callOptions.retryAttempts ?? 1,
+        retryBaseMs: callOptions.retryBaseMs ?? options.uploadRetryBaseMs,
+        dispatcher,
+        hint: telegramNetworkHint(options.proxyUrl),
+        logger: logger$2,
+    });
+}
+
+/** Download chunk bytes by Telegram `file_id` stored in Chunk.url. */
+async function downloadTelegramChunk(options, fileId) {
+    const file = await callTelegramApi(options, `getFile?file_id=${encodeURIComponent(fileId)}`, { method: "GET" }, {
+        retryAttempts: options.uploadRetryAttempts,
+        retryBaseMs: options.uploadRetryBaseMs,
+    });
+    if (file.file_path == null || file.file_path === "") {
+        throw new Error(`Telegram getFile: missing file_path for file_id ${fileId}`);
+    }
+    return telegramDownloadBinary(options, telegramFileDownloadUrl(options, file.file_path), `download:${fileId.slice(0, 12)}…`, {
+        timeoutMs: options.uploadTimeoutMs,
+        retryAttempts: options.uploadRetryAttempts,
+        retryBaseMs: options.uploadRetryBaseMs,
+    });
+}
+
+/**
+ * Telegram chunk URL encoding: `${messageId}|${fileId}`.
+ * Legacy parcels store bare `file_id` (no messageId → cannot deleteMessage).
+ */
+const SEPARATOR = "|";
+function encodeTelegramChunkUrl(messageId, fileId) {
+    return `${messageId}${SEPARATOR}${fileId}`;
+}
+function parseTelegramChunkUrl(locator) {
+    const idx = locator.indexOf(SEPARATOR);
+    if (idx <= 0) {
+        return { messageId: null, fileId: locator };
+    }
+    const mid = Number(locator.slice(0, idx));
+    const fileId = locator.slice(idx + 1);
+    if (!Number.isInteger(mid) || mid <= 0 || fileId === "") {
+        return { messageId: null, fileId: locator };
+    }
+    return { messageId: mid, fileId };
+}
+
+function resolveTelegramStorageOptions(options) {
+    const botToken = options.botToken.trim();
+    const chatId = options.chatId.trim();
+    if (botToken === "") {
+        throw new Error("TelegramStorageProviderOptions.botToken is required");
+    }
+    if (chatId === "") {
+        throw new Error("TelegramStorageProviderOptions.chatId is required");
+    }
+    const apiBaseUrl = (options.apiBaseUrl?.trim() || "https://api.telegram.org").replace(/\/$/, "");
+    const proxyUrl = options.proxyUrl?.trim() || undefined;
+    return {
+        botToken,
+        chatId,
+        apiBaseUrl,
+        proxyUrl: proxyUrl !== "" ? proxyUrl : undefined,
+        fetchTimeoutMs: options.fetchTimeoutMs ?? 30_000,
+        uploadTimeoutMs: options.uploadTimeoutMs ?? 120_000,
+        uploadRetryAttempts: options.uploadRetryAttempts ?? 3,
+        uploadRetryBaseMs: options.uploadRetryBaseMs ?? 2_000,
+    };
+}
+
+const PROVIDER_TELEGRAM = "telegram";
+async function uploadChunkToTelegram(options, data, filename) {
+    const sizeMb = (data.byteLength / (1024 * 1024)).toFixed(2);
+    const message = await callTelegramApi(options, "sendDocument", () => {
+        const form = new FormData();
+        form.append("chat_id", options.chatId);
+        form.append("document", new Blob([data]), filename);
+        return { method: "POST", body: form };
+    }, {
+        timeoutMs: options.uploadTimeoutMs,
+        retryAttempts: options.uploadRetryAttempts,
+        retryBaseMs: options.uploadRetryBaseMs,
+    });
+    const fileId = message.document?.file_id;
+    if (fileId == null || fileId === "") {
+        throw new Error(`Telegram sendDocument: missing file_id (chunk ${filename}, ${sizeMb} MB)`);
+    }
+    return { fileId, messageId: message.message_id };
+}
+async function deleteTelegramMessage(options, messageId) {
+    await callTelegramApi(options, "deleteMessage", () => {
+        const form = new FormData();
+        form.append("chat_id", options.chatId);
+        form.append("message_id", String(messageId));
+        return { method: "POST", body: form };
+    }, {
+        retryAttempts: 3,
+        retryBaseMs: 1_000,
+    });
+}
+async function rollbackTelegramUploads(options, handles) {
+    for (const item of handles) {
+        const upload = item;
+        if (upload?.messageId == null) {
+            continue;
+        }
+        try {
+            await deleteTelegramMessage(options, upload.messageId);
+        }
+        catch {
+            // Best-effort cleanup
+        }
+    }
+}
+function assertTelegramParcel(parcel) {
+    const chunks = parcel.details.chunkList;
+    if (chunks.length === 0) {
+        throw new Error("Parcel has no chunks");
+    }
+    const nonTelegram = chunks.filter((chunk) => chunk.provider != null && chunk.provider !== PROVIDER_TELEGRAM);
+    if (nonTelegram.length > 0) {
+        const providers = [...new Set(nonTelegram.map((chunk) => chunk.provider))];
+        throw new Error(`Parcel is not telegram-only (found providers: ${providers.join(", ")}). ` +
+            "Multi-provider restore is not yet supported for this parcel.");
+    }
+}
+/**
+ * Build a Telegram {@link StorageProviderModule}. Caller registers it — no side effects.
+ *
+ * @example
+ * ```ts
+ * import { createStorageProviderRegistry, createTelegramStorageProvider } from "target-supabase-sdk/node";
+ * const registry = createStorageProviderRegistry();
+ * registry.register(createTelegramStorageProvider({ botToken, chatId, proxyUrl }));
+ * ```
+ */
+function createTelegramStorageProvider(input) {
+    const options = resolveTelegramStorageOptions(input);
+    return {
+        provider: PROVIDER_TELEGRAM,
+        uploadChunk: (data, filename) => uploadChunkToTelegram(options, data, filename),
+        deleteMessage: (messageId) => deleteTelegramMessage(options, messageId),
+        async deleteChunkBlobs(parcel) {
+            let deleted = 0;
+            let failed = 0;
+            let skipped = 0;
+            for (const chunk of parcel.details.chunkList) {
+                if (chunk.provider != null && chunk.provider !== PROVIDER_TELEGRAM) {
+                    skipped += 1;
+                    continue;
+                }
+                const { messageId } = parseTelegramChunkUrl(chunk.url);
+                if (messageId == null) {
+                    skipped += 1;
+                    continue;
+                }
+                try {
+                    await deleteTelegramMessage(options, messageId);
+                    deleted += 1;
+                }
+                catch {
+                    failed += 1;
+                }
+            }
+            return { deleted, failed, skipped };
+        },
+        createUploadAdapter(adapterOptions) {
+            const tracker = adapterOptions?.tracker;
+            return {
+                provider: PROVIDER_TELEGRAM,
+                async upload(data, pathOrKey) {
+                    const result = await uploadChunkToTelegram(options, data, pathOrKey);
+                    tracker?.push(result);
+                    // Persist messageId so later deleteParcel can call deleteMessage.
+                    return { url: encodeTelegramChunkUrl(result.messageId, result.fileId) };
+                },
+            };
+        },
+        resolveChunk: (locator) => {
+            const { fileId } = parseTelegramChunkUrl(locator);
+            return downloadTelegramChunk(options, fileId);
+        },
+        matchesOpaqueUrl: isOpaqueChunkUrl,
+        async probe() {
+            try {
+                const me = await callTelegramApi(options, "getMe", { method: "GET" });
+                return { ok: true, detail: { username: me.username ?? "unknown" } };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { ok: false, error: message };
+            }
+        },
+        rollbackUpload: (handles) => rollbackTelegramUploads(options, handles),
+        assertParcelRestorable: assertTelegramParcel,
+    };
+}
+
 /** Supabase `target.category` for rows that store task script payloads */
 const TASK_REPO_SCRIPT_CATEGORY = "script";
 /** Host app config directory (relative to `cwd`) — recommended for library consumers */
@@ -3065,6 +3355,247 @@ const RepoManager = {
     clearRepoScriptModuleCache,
 };
 
+function sameStorageHost$1(storageProvider, localStorageProvider) {
+    return storageProvider.trim() === localStorageProvider.trim();
+}
+function isFeedDirectoryValue(value) {
+    return value === "feed.image-list";
+}
+/**
+ * Local reachability for feed ingest (`.local` source).
+ *
+ * - Requires `storageProvider === localStorageProvider`.
+ * - `locator` must be an absolute path.
+ * - `feed.image-list`: directory exists.
+ * - Other feed values: non-empty file.
+ *
+ * **Node-only**
+ */
+async function checkFeedLocalAvailability(input) {
+    const storageProvider = input.storageProvider.trim();
+    const localStorageProvider = input.localStorageProvider.trim();
+    const locator = input.locator.trim();
+    if (storageProvider === "" || localStorageProvider === "") {
+        return { ok: false, reason: "storageProvider and localStorageProvider are required" };
+    }
+    if (locator === "") {
+        return { ok: false, reason: "locator is empty" };
+    }
+    if (!sameStorageHost$1(storageProvider, localStorageProvider)) {
+        return {
+            ok: false,
+            reason: `storageProvider not on this host (${storageProvider} !== ${localStorageProvider})`,
+        };
+    }
+    if (!isAbsolute(locator)) {
+        return { ok: false, reason: `locator must be an absolute path: ${locator}` };
+    }
+    const absolutePath = resolve(locator);
+    try {
+        const info = await stat(absolutePath);
+        if (isFeedDirectoryValue(input.value)) {
+            if (!info.isDirectory()) {
+                return { ok: false, reason: `feed.image-list locator is not a directory: ${absolutePath}` };
+            }
+            return { ok: true, absolutePath };
+        }
+        if (!info.isFile()) {
+            return { ok: false, reason: `locator is not a file: ${absolutePath}` };
+        }
+        if (info.size <= 0) {
+            return { ok: false, reason: `file is empty: ${absolutePath}` };
+        }
+        return { ok: true, absolutePath };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, reason: `locator not reachable: ${absolutePath} (${message})` };
+    }
+}
+const OSS_CHECK_TIMEOUT_MS = 15_000;
+const OSS_CHECK_MAX_ATTEMPTS = 2;
+async function probeHttpLocator(locator, method) {
+    return fetchWithRetry(locator, {
+        method,
+        ...(method === "GET" ? { headers: { Range: "bytes=0-0" } } : {}),
+    }, {
+        label: "feed-oss-check",
+        timeoutMs: OSS_CHECK_TIMEOUT_MS,
+        maxAttempts: OSS_CHECK_MAX_ATTEMPTS,
+    });
+}
+/**
+ * Remote reachability for feed ingest (`.oss` source) via HTTP(S).
+ *
+ * Tries `HEAD`, then `GET` with `Range: bytes=0-0` when `HEAD` is not allowed.
+ *
+ * **Node-only**
+ */
+async function checkFeedOssAvailability(locator) {
+    const trimmed = locator.trim();
+    if (trimmed === "") {
+        return { ok: false, reason: "locator is empty" };
+    }
+    if (!isHttpUrl(trimmed)) {
+        return { ok: false, reason: `oss locator must be an http(s) URL: ${trimmed}` };
+    }
+    try {
+        let response = await probeHttpLocator(trimmed, "HEAD");
+        if (response.status === 405 || response.status === 501) {
+            response = await probeHttpLocator(trimmed, "GET");
+        }
+        if (response.ok || (response.status >= 200 && response.status < 400)) {
+            return { ok: true };
+        }
+        return { ok: false, reason: `oss locator HTTP ${response.status}: ${trimmed}` };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, reason: `oss locator request failed: ${trimmed} (${message})` };
+    }
+}
+
+const logger$1 = createLogger({ module: "feed" });
+function parseFeedOriginal(original) {
+    if (original == null || typeof original !== "object") {
+        return null;
+    }
+    const record = original;
+    const storageProvider = typeof record.storageProvider === "string" ? record.storageProvider : null;
+    const locator = typeof record.locator === "string" ? record.locator : null;
+    if (storageProvider == null || locator == null) {
+        return null;
+    }
+    const twinList = Array.isArray(record.twinList)
+        ? record.twinList.filter((entry) => typeof entry === "string")
+        : undefined;
+    return {
+        storageProvider,
+        locator,
+        ...(twinList !== undefined ? { twinList } : {}),
+    };
+}
+function assertFeedLink(target) {
+    if (target.category !== CategoryLink.LINK) {
+        throw new Error(`registerFeed: target is not a link (category=${target.category})`);
+    }
+    if (!isFeedValue(target.value)) {
+        throw new Error(`registerFeed: target value is not a feed loader: ${target.value}`);
+    }
+    const details = target.details;
+    if (details == null || details.loaderKey !== target.value) {
+        throw new Error("registerFeed: invalid feed link details (loaderKey must equal value)");
+    }
+    return target;
+}
+function hasIngestSourceTag(tagList) {
+    return tagList.some((tag) => tag === ".local" || tag === ".oss");
+}
+function isSameIngestState(link, source, storageProvider, locator) {
+    if (!link.tagList.includes(source)) {
+        return false;
+    }
+    const original = parseFeedOriginal(link.details.original);
+    if (original == null) {
+        return false;
+    }
+    return original.storageProvider === storageProvider && original.locator === locator;
+}
+/**
+ * Ingest a `.public` feed Link: validate locator, then promote `tagList` source to `.local` or `.oss`
+ * and update `details.original.storageProvider` + `locator`.
+ *
+ * **Node-only** — under `shared/feed/node/`; do not import from the browser entry.
+ */
+async function registerFeed(input) {
+    const id = input.id.trim();
+    if (id === "") {
+        throw new Error("registerFeed: id is empty");
+    }
+    if (!isFeedIngestSource(input.source)) {
+        throw new Error(`registerFeed: source must be .local or .oss, got ${String(input.source)}`);
+    }
+    const resolvedStorageProvider = resolveFeedOriginalStorageProvider(input.source, input.storageProvider);
+    const locator = input.locator.trim();
+    if (locator === "") {
+        throw new Error("registerFeed: locator is empty");
+    }
+    const { data: target } = await getTarget({ id });
+    if (target == null) {
+        throw new Error(`registerFeed: target not found: ${id}`);
+    }
+    const link = assertFeedLink(target);
+    const feedValue = link.value;
+    if (!link.tagList.includes(".public")) {
+        if (isSameIngestState(link, input.source, resolvedStorageProvider, locator)) {
+            logger$1.info("feed already ingested", {
+                topic: "dedup",
+                data: { id, source: input.source, locator },
+            });
+            return { id, updated: false };
+        }
+        if (hasIngestSourceTag(link.tagList)) {
+            throw new Error("registerFeed: feed already ingested with different source, storageProvider, or locator");
+        }
+        throw new Error("registerFeed: feed is not .public — cannot ingest");
+    }
+    if (input.source === ".local") {
+        const localStorageProvider = input.localStorageProvider?.trim() ?? "";
+        if (localStorageProvider === "") {
+            throw new Error("registerFeed: localStorageProvider is required when source is .local");
+        }
+        const availability = await checkFeedLocalAvailability({
+            value: feedValue,
+            storageProvider: resolvedStorageProvider,
+            locator,
+            localStorageProvider,
+        });
+        if (!availability.ok) {
+            throw new Error(`registerFeed: local locator unavailable — ${availability.reason ?? "unknown"}`);
+        }
+    }
+    else {
+        const availability = await checkFeedOssAvailability(locator);
+        if (!availability.ok) {
+            throw new Error(`registerFeed: oss locator unavailable — ${availability.reason ?? "unknown"}`);
+        }
+    }
+    await updateTarget({
+        id,
+        optimisticLockFilterList: [
+            { field: "category", operator: "eq", value: CategoryLink.LINK },
+            { field: "details->original->>storageProvider", operator: "eq", value: "" },
+        ],
+        updateFn: (row) => {
+            if (!row.tagList.includes(".public")) {
+                throw new Error("registerFeed: optimistic lock failed — .public tag missing");
+            }
+            if (hasIngestSourceTag(row.tagList) && !row.tagList.includes(".public")) {
+                throw new Error("registerFeed: feed already ingested");
+            }
+            const details = row.details;
+            const prior = parseFeedOriginal(details.original);
+            const nextOriginal = {
+                storageProvider: resolvedStorageProvider,
+                locator,
+                ...(prior?.twinList !== undefined ? { twinList: prior.twinList } : {}),
+            };
+            return {
+                tagList: buildFeedTagList(input.source, row.tagList),
+                details: {
+                    ...details,
+                    original: nextOriginal,
+                },
+            };
+        },
+    });
+    logger$1.info("feed ingested", {
+        topic: "register",
+        data: { id, source: input.source, storageProvider: resolvedStorageProvider, locator },
+    });
+    return { id, updated: true };
+}
+
 function createLogSpoolCoordinator(options) {
     const { serviceValue, serviceId } = options;
     return {
@@ -4241,5 +4772,5 @@ const patchTriggerFired = validateWithSchema(patchTriggerFiredSchema, "patchTrig
     }
 });
 
-export { BaseNodeRuntime, COLLECT_LOG_RUNNER_KEY, CategoryCommand, CategoryNode, CategoryRepo, CategoryTrigger, CommandType, EMPTY_REGISTRY_SLOT_RUNTIME_STATE, LOG_SPOOL_SERVICE_ID_ENV, LOG_TOPIC_TRIGGER, LogLevel, MAX_POLL_TARGET_LIST_SIZE, MEDIA_CONTENT_HASH_ALGORITHM, ManagedChildProcesses, NodeStatus, RepoManager, ResultCode, SERVICE_GUARD_RUNNER_KEY, ServiceGuardNode, ServiceRegistryError, TASK_LOCAL_PACKAGE_CONFIG_FILENAME, TASK_REPO_SCRIPT_CATEGORY, TASK_REPO_USAGE, TASK_RUNNER_CONFIG_DIR, TASK_RUNNER_ROOT_CONFIG_FILENAME, TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH, TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH, TRIGGER_LOOP_INTERVAL_MS, TRIGGER_RUNNER_DEFAULT_RETRY_COUNT, TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS, TaskManager, TaskNode, TaskRepoValidation, TaskStatus, TaskStatusAction, TriggerManager, TriggerNode, TriggerStatus, applyRegistrySlotGuardStep, buildMediaLinkDraft, buildNodeImportArgs, checkMediaAvailability, claimServiceRegistrySlot, createJsonFileStateStore, createL3ChildLauncher, createLogSpoolCoordinator, createLogger, createManagedChildProcesses, createPathsExistCheck, createRequiredEnvCheck, createServiceHost, createServiceRuntimeStateStore, createSupabaseReachableCheck, createTarget, enableLogSpoolFromEnvInChild, ensureLogSpoolFromEnv, evaluateBusyNodeLiveness, findMediaLink, generateResponse, getConfigFileDir, getLogSpoolStats, getMainLogSpoolWriterStats, getPollCommandList, getPollCommandListSchema, getPossibleTarget, getScanRemoteRepoValues, guardRetryAfterSec, guessMediaMime, importJsConfigModule, initSupabaseFromStandardEnv, isChildProcessRunning, isCreateTargetAlreadyExistsError, isGuardAvailable, isLogEntry, isLogSpoolEnabled, isMediaValue, isOptimisticLockResponse, loadCachedJsConfigModule, loadEnvFiles, logManager, logSpoolEnabledFromEnv, markWorkerSpawned, mediaLinkDedupFilters, nodeBufferToArrayBuffer, patchChangeNodeStatus, patchChangeTaskStatus, patchClaimTask, patchNodeHeartBeat, patchServiceRuntime, patchStopNode, patchTriggerFired, patchTriggerFiredSchema, pathExists, pollTargetList, pollUntil, postCommand, postCommandSchema, postRegisterNode, postTarget, postTaskSchema, postTaskWithValidation, postTrigger, postTriggerSchema, probeMediaOriginal, publicBaseUrlFromEnv, readAndVerifySourceFile, readEnv, registerCollectLogRunner, registerMediaLink, registerServiceGuardRunner, registrySlotRuntimePatchFromGuardResult, requireEnv, resolveFirstExistingPath, resolveLogSpoolRoot, resolvePathFromBaseDir, resolvePathFromConfigFile, resolvePathFromCwd, runCollectLogTick, runReadinessChecks, runReadinessGate, runRegistrySlotGuardCheck, runServiceGuardTick, runSingleProcessService, scanEnabledTriggers, scanEnabledTriggersSchema, scanTargetList, sha256Hex, shutdownLogSpool, shutdownLogSpoolFromEnv, spawnTsxChild, supabase, toFileImportHref, updateTargetDetails, validateTaskRepoAndParams, validateWithSchema, waitForServiceReady };
+export { BaseNodeRuntime, COLLECT_LOG_RUNNER_KEY, CategoryCommand, CategoryLink, CategoryNode, CategoryRepo, CategoryTrigger, CommandType, EMPTY_REGISTRY_SLOT_RUNTIME_STATE, LOG_SPOOL_SERVICE_ID_ENV, LOG_TOPIC_TRIGGER, LogLevel, MAX_POLL_TARGET_LIST_SIZE, MEDIA_CONTENT_HASH_ALGORITHM, ManagedChildProcesses, NodeStatus, PROVIDER_TELEGRAM, RepoManager, ResultCode, SERVICE_GUARD_RUNNER_KEY, ServiceGuardNode, ServiceRegistryError, TASK_LOCAL_PACKAGE_CONFIG_FILENAME, TASK_REPO_SCRIPT_CATEGORY, TASK_REPO_USAGE, TASK_RUNNER_CONFIG_DIR, TASK_RUNNER_ROOT_CONFIG_FILENAME, TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH, TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH, TRIGGER_LOOP_INTERVAL_MS, TRIGGER_RUNNER_DEFAULT_RETRY_COUNT, TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS, TaskManager, TaskNode, TaskRepoValidation, TaskStatus, TaskStatusAction, TriggerManager, TriggerNode, TriggerStatus, applyRegistrySlotGuardStep, buildMediaLinkDraft, buildNodeImportArgs, callTelegramApi, checkFeedLocalAvailability, checkFeedOssAvailability, checkMediaAvailability, claimServiceRegistrySlot, createJsonFileStateStore, createL3ChildLauncher, createLogSpoolCoordinator, createLogger, createManagedChildProcesses, createPathsExistCheck, createRequiredEnvCheck, createServiceHost, createServiceRuntimeStateStore, createSupabaseReachableCheck, createTarget, createTelegramStorageProvider, downloadTelegramChunk, enableLogSpoolFromEnvInChild, encodeTelegramChunkUrl, ensureLogSpoolFromEnv, evaluateBusyNodeLiveness, fetchBinaryWithRetry, fetchWithRetry, findMediaLink, generateResponse, getConfigFileDir, getLogSpoolStats, getMainLogSpoolWriterStats, getPollCommandList, getPollCommandListSchema, getPossibleTarget, getScanRemoteRepoValues, getTarget, guardRetryAfterSec, guessMediaMime, importJsConfigModule, initSupabaseFromStandardEnv, isChildProcessRunning, isCreateTargetAlreadyExistsError, isFeedIngestSource, isFeedValue, isGuardAvailable, isHttpUrl, isLogEntry, isLogSpoolEnabled, isMediaValue, isOpaqueChunkUrl, isOptimisticLockResponse, isRetryableHttpStatus, loadCachedJsConfigModule, loadEnvFiles, logManager, logSpoolEnabledFromEnv, markWorkerSpawned, mediaLinkDedupFilters, nodeBufferToArrayBuffer, parseTelegramChunkUrl, patchChangeNodeStatus, patchChangeTaskStatus, patchClaimTask, patchNodeHeartBeat, patchServiceRuntime, patchStopNode, patchTriggerFired, patchTriggerFiredSchema, pathExists, pollTargetList, pollUntil, postCommand, postCommandSchema, postRegisterNode, postTarget, postTaskSchema, postTaskWithValidation, postTrigger, postTriggerSchema, probeMediaOriginal, publicBaseUrlFromEnv, readAndVerifySourceFile, readEnv, registerCollectLogRunner, registerFeed, registerMediaLink, registerServiceGuardRunner, registrySlotRuntimePatchFromGuardResult, requireEnv, resolveFirstExistingPath, resolveLogSpoolRoot, resolvePathFromBaseDir, resolvePathFromConfigFile, resolvePathFromCwd, resolveTelegramStorageOptions, runCollectLogTick, runReadinessChecks, runReadinessGate, runRegistrySlotGuardCheck, runServiceGuardTick, runSingleProcessService, scanEnabledTriggers, scanEnabledTriggersSchema, scanTargetList, sha256Hex, shutdownLogSpool, shutdownLogSpoolFromEnv, spawnTsxChild, supabase, telegramDownloadBinary, telegramFileDownloadUrl, toFileImportHref, updateTarget, updateTargetDetails, validateTaskRepoAndParams, validateWithSchema, waitForServiceReady };
 //# sourceMappingURL=node.js.map