target-supabase-sdk 0.2.16 → 0.2.18

package/dist/node.js

@@ -1,19 +1,20 @@
 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, 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, q as isCreateTargetAlreadyExistsError, r as isDevEnvironment, s as isOptimisticLockError, u as logDev, v as logDevGroup, x as logMinLevelFromEnv, y as patchTarget, A as postListCreate, D as postLogListCreate, E as postTarget, 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, 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 { 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 { bi as sha256Hex, bo as getErrorMessage, bp as LOG_TOPIC_NODE, aM as postRegisterNode, aq as patchChangeNodeStatus, N as NodeStatus, aB as patchStopNode, ay as patchNodeHeartBeat, E as EMPTY_REGISTRY_SLOT_RUNTIME_STATE, b8 as runRegistrySlotGuardCheck, a_ as registrySlotRuntimePatchFromGuardResult, c as CategoryNode, U as evaluateBusyNodeLiveness, aA as patchServiceRuntime, ah as isLogEntry, x as claimServiceRegistrySlot, k as ServiceRegistryError, e as CategoryRepo, R as ResultCode, bq as LOG_TOPIC_TASK, m as TASK_REPO_USAGE, a7 as getScanRemoteRepoValues, au as patchClaimTask, br as CRITICAL_UNKNOWN_TASK_TRACE_ID, as as patchChangeTaskStatus, o as TaskStatusAction, bs as toError, aU as postTaskSchema, bt as createTaskRow, n as TaskStatus } from './chunks/task-queue-Gi4DSq74.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, P as POST_TASK_DEFAULT_MAX_ATTEMPTS, i as ParcelManager, j as PostLinkValidator, S as ServiceLifecycleStatus, l as ServiceSlotStatus, T as TARGET_SYSTEM_REGISTRY_KEY, p as apiDetailsSchema, q as appendSystemRegistryEmptySlots, r as assertRegistrySlotAvailable, s as assertRegistrySlotOwner, t as buildEmptyServiceSlots, u as buildLinkTargetDraft, v as buildListTargetDraft, w as buildSystemRegistryConfigDetails, y as classifyNetworkError, z as countTasksByType, B as createActiveServiceLifecycle, F as createClaimedRegistrySlotRuntimeState, G as createStorageProviderRegistry, H as createUploadTracker, I as decodeLogBatch, J as decodeLogBatchList, K as defaultL3ServiceDetails, M as deleteParcel, O as deleteParcelSchema, Q as escapeIlikePattern, V as fetchBinaryWithRetry, W as fetchWithRetry, X as fieldDefinitionSchema, Y as flattenLogBatch, Z as flattenLogBatches, _ as formatNetworkError, $ as getApi, a0 as getApiSchema, a1 as getConfig, a2 as getConfigSchema, a3 as getExtraction, a4 as getExtractionSchema, a5 as getParcel, a6 as getParcelSchema, a8 as getScanRemoteRepoValuesSchema, a9 as getService, aa as getServiceSchema, ab as getTargetSystemRegistry, ac as getValueAtPath, ad as installChunkFetchRegistry, ae as isHttpUrl, af as isLocalFilesystemPath, ag as isLogBatchList, ai as isOpaqueChunkUrl, aj as isRetryableHttpStatus, ak as linkTargetDraftBuildInputSchema, al as parcelDetailsSchema, am as parseLogBatchMeta, an as parseProviderPrefixedUrl, ao as parseServiceSlot, ap as parseServiceSlots, ar as patchChangeNodeStatusSchema, at as patchChangeTaskStatusSchema, av as patchClaimTaskSchema, aw as patchExtractionObjects, ax as patchExtractionObjectsSchema, az as patchNodeHeartBeatSchema, aC as patchStopNodeSchema, aD as patchTaskProgress, aE as patchTaskProgressSchema, aF as postApi, aG as postApiSchema, aH as postExtraction, aI as postExtractionSchema, aJ as postLinkCreate, aK as postParcel, aL as postParcelSchema, aN as postRegisterNodeSchema, aO as postService, aP as postServiceInstance, aQ as postServiceSchema, aR as postSystemRegistryConfig, aS as postSystemRegistryConfigSchema, aT as postTask, aV as postTaskWithRetry, aW as publishParcel, aX as registerProviderChunkResolver, aY as registerService, aZ as registerServiceAtStartup, a$ as releaseSystemRegistrySlots, b0 as releaseSystemRegistrySlotsByServiceId, b1 as requestHasBody, b2 as resetSystemRegistryConfig, b3 as resetSystemRegistryConfigSchema, b4 as resolveActiveRegistryServiceId, b5 as resolveFetchUrl, b6 as restoreParcel, b7 as restoreParcelById, b9 as sanitizeFileName, ba as sanitizeParcelFileName, bb as scanExtractionList, bc as scanExtractionListSchema, bd as schemaDefinitionSchema, be as serviceDetailsSchema, bf as serviceLifecycleSchema, bg as serviceNodeSnapshotSchema, bh as serviceRuntimeSchema, bj as summarizeTaskQueue, bk as systemRegistrySeedSlotSchema, bl as toPostgrestTextArrayLiteral, bm as unregisterService, bn as unregisterServiceAtShutdown } from './chunks/task-queue-Gi4DSq74.js';
+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, $ as fetchWithRetry, aq as isRetryableHttpStatus, _ as fetchBinaryWithRetry, ap as isOpaqueChunkUrl, 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, 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, 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 { spawn } from 'node:child_process';
+import { ProxyAgent } from 'undici';
 import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
+import { createReadStream } from 'node:fs';
 import 'lodash-es';
 import '@supabase/supabase-js';
-import 'node:fs';
 
 var CategoryCommand;
 (function (CategoryCommand) {
@@ -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$1 = 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$1,
+        });
+        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$1.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$1.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$1,
+    });
+}
+
+/** 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 */
@@ -3125,6 +3415,211 @@ async function shutdownLogSpool() {
     await shutdownLogSpoolFromEnv();
 }
 
+function sameStorageHost(storageProvider, localStorageProvider) {
+    return storageProvider.trim() === localStorageProvider.trim();
+}
+async function sha256FileStreaming(absolutePath) {
+    return await new Promise((resolveHash, reject) => {
+        const hash = createHash(MEDIA_CONTENT_HASH_ALGORITHM);
+        const stream = createReadStream(absolutePath);
+        stream.on("data", (chunk) => {
+            hash.update(chunk);
+        });
+        stream.on("error", reject);
+        stream.on("end", () => {
+            resolveHash(hash.digest("hex"));
+        });
+    });
+}
+async function countFilesOneLevel(dirPath) {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    let count = 0;
+    for (const entry of entries) {
+        if (entry.isFile()) {
+            count += 1;
+        }
+    }
+    return count;
+}
+/**
+ * Fast local reachability check for a media locator.
+ *
+ * - Requires `storageProvider === localStorageProvider` (cross-host → not ok).
+ * - `locator` must be an absolute path.
+ * - `image-list`: directory exists; only immediate children are considered.
+ * - other values: path exists and is a non-empty file.
+ *
+ * **Node-only** — under `shared/media/node/`; do not import from the browser entry.
+ */
+async function checkMediaAvailability(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(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 (input.value === "image-list") {
+            if (!info.isDirectory()) {
+                return { ok: false, reason: `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})` };
+    }
+}
+/**
+ * Derive `contentHash` / `size` / `mimeType` for {@link MediaOriginal} after availability succeeds.
+ *
+ * **Node-only** — under `shared/media/node/`; do not import from the browser entry.
+ */
+async function probeMediaOriginal(input) {
+    const storageProvider = input.storageProvider.trim();
+    const locator = input.locator.trim();
+    if (input.value === "image-list") {
+        const size = await countFilesOneLevel(input.absolutePath);
+        return {
+            storageProvider,
+            locator,
+            contentHash: "",
+            size,
+            mimeType: "",
+        };
+    }
+    const info = await stat(input.absolutePath);
+    const mimeType = guessMediaMime(input.absolutePath, input.value);
+    if (mimeType == null) {
+        throw new Error(`probeMediaOriginal: cannot guess mimeType for ${input.value}: ${input.absolutePath}`);
+    }
+    const contentHash = await sha256FileStreaming(input.absolutePath);
+    return {
+        storageProvider,
+        locator,
+        contentHash,
+        size: info.size,
+        mimeType,
+    };
+}
+
+const logger = createLogger({ module: "media" });
+/** Dedup lookup: same `category` + `value` + `name`. */
+async function findMediaLink(input) {
+    if (!isMediaValue(input.value)) {
+        throw new Error(`findMediaLink: unsupported media value: ${String(input.value)}`);
+    }
+    const name = input.name.trim();
+    if (name === "") {
+        throw new Error("findMediaLink: name is empty");
+    }
+    const { data } = await getPossibleTarget({
+        filterList: mediaLinkDedupFilters({ value: input.value, name }),
+    });
+    return data != null ? data : null;
+}
+/**
+ * Register a media Link: dedup → availability → probe → `postTarget`.
+ * Idempotent when `category`+`value`+`name` already exist.
+ *
+ * **Node-only** — under `shared/media/node/`; do not import from the browser entry.
+ */
+async function registerMediaLink(input) {
+    if (!isMediaValue(input.value)) {
+        throw new Error(`registerMediaLink: unsupported media value: ${String(input.value)}`);
+    }
+    const name = input.name.trim();
+    if (name === "") {
+        throw new Error("registerMediaLink: name is empty");
+    }
+    const existing = await findMediaLink({ value: input.value, name });
+    if (existing != null) {
+        logger.info("media already registered", {
+            topic: "dedup",
+            data: { id: existing.id, value: input.value, name },
+        });
+        return { id: existing.id, created: false };
+    }
+    const availability = await checkMediaAvailability({
+        value: input.value,
+        storageProvider: input.storageProvider,
+        locator: input.locator,
+        localStorageProvider: input.localStorageProvider,
+    });
+    if (!availability.ok || availability.absolutePath == null) {
+        throw new Error(`registerMediaLink: unavailable — ${availability.reason ?? "unknown"}`);
+    }
+    const probed = await probeMediaOriginal({
+        value: input.value,
+        storageProvider: input.storageProvider,
+        locator: input.locator,
+        absolutePath: availability.absolutePath,
+    });
+    const draft = buildMediaLinkDraft({
+        value: input.value,
+        name,
+        storageProvider: probed.storageProvider,
+        locator: probed.locator,
+        contentHash: probed.contentHash,
+        size: probed.size,
+        mimeType: probed.mimeType,
+        description: input.description,
+        tagList: input.tagList,
+    });
+    try {
+        const { data, error } = await postTarget({
+            name: draft.name,
+            value: draft.value,
+            category: draft.category,
+            tagList: draft.tagList,
+            details: draft.details,
+        });
+        if (error != null || data == null) {
+            throw new Error(error?.message ?? "registerMediaLink: postTarget failed");
+        }
+        logger.info("media registered", {
+            topic: "register",
+            data: { id: data.id, value: input.value, name, size: probed.size },
+        });
+        return { id: data.id, created: true };
+    }
+    catch (error) {
+        if (isCreateTargetAlreadyExistsError(error)) {
+            const raced = await findMediaLink({ value: input.value, name });
+            if (raced != null) {
+                logger.info("media register race — using existing", {
+                    topic: "dedup",
+                    data: { id: raced.id, value: input.value, name },
+                });
+                return { id: raced.id, created: false };
+            }
+        }
+        throw error;
+    }
+}
+
 const EMPTY_RESULT = {
     status: "not_configured",
     registered: [],
@@ -4036,5 +4531,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, 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, buildNodeImportArgs, claimServiceRegistrySlot, createJsonFileStateStore, createL3ChildLauncher, createLogSpoolCoordinator, createLogger, createManagedChildProcesses, createPathsExistCheck, createRequiredEnvCheck, createServiceHost, createServiceRuntimeStateStore, createSupabaseReachableCheck, createTarget, enableLogSpoolFromEnvInChild, ensureLogSpoolFromEnv, evaluateBusyNodeLiveness, generateResponse, getConfigFileDir, getLogSpoolStats, getMainLogSpoolWriterStats, getPollCommandList, getPollCommandListSchema, getPossibleTarget, getScanRemoteRepoValues, guardRetryAfterSec, importJsConfigModule, initSupabaseFromStandardEnv, isChildProcessRunning, isGuardAvailable, isLogEntry, isLogSpoolEnabled, isOptimisticLockResponse, loadCachedJsConfigModule, loadEnvFiles, logManager, logSpoolEnabledFromEnv, markWorkerSpawned, nodeBufferToArrayBuffer, patchChangeNodeStatus, patchChangeTaskStatus, patchClaimTask, patchNodeHeartBeat, patchServiceRuntime, patchStopNode, patchTriggerFired, patchTriggerFiredSchema, pathExists, pollTargetList, pollUntil, postCommand, postCommandSchema, postRegisterNode, postTaskSchema, postTaskWithValidation, postTrigger, postTriggerSchema, publicBaseUrlFromEnv, readAndVerifySourceFile, readEnv, registerCollectLogRunner, 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, 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, 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, guardRetryAfterSec, guessMediaMime, importJsConfigModule, initSupabaseFromStandardEnv, isChildProcessRunning, isCreateTargetAlreadyExistsError, isGuardAvailable, 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, 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, updateTargetDetails, validateTaskRepoAndParams, validateWithSchema, waitForServiceReady };
 //# sourceMappingURL=node.js.map