stitchkit 0.100.3 → 0.101.1

package/dist/entrypoints/index.d.ts

@@ -1,3 +1,4 @@
+export { type ChunkedUploadConfig, type ChunkedUploadPart, type ChunkedUploadProgress, type ChunkedUploadStart, uploadInChunks, } from '../browser/chunked-upload.js';
 export { type ClientConfig, type ClientContract, type ClientFetch, type ClientRegistryValue, type ContractClientConfig, contractEndpointMatchers, createClient, createClients, createScopedClients, createScopedUrlBuilders, createUrlBuilder, createUrlBuilders, type PathPrefixArgs, type RegistryScope, type ScopeClientConfigs, type ScopedClientRegistry, type ScopedUrlBuilderRegistry, type UrlBuilderConfig, } from '../browser/client.js';
 export { ApiError, type ApiEvent, type ApiEventListener, type ConfiguredHttpClient, createHttpClient, type HeaderProvider, type HttpClient, type HttpClientConfig, type RequestOptions, type UnauthorizedMatcher, } from '../browser/http.js';
 export { createLiveStateController, type LiveStateController, type LiveStateControllerConfig, type LiveStateControllerError, type LiveStateControllerSnapshot, type LiveStateControllerStatus, LiveStateControllerStatusSchema, type LiveStateEventDecision, type LiveStatePhase, LiveStatePhaseSchema, type LiveStateSource, type LiveStateSourceOpenInput, type LiveStateSourceOpenResult, type LiveStateStopReason, LiveStateStopReasonSchema, type LiveStateSubscriberError, } from '../browser/live-state.js';

package/dist/entrypoints/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entrypoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,wBAAwB,EACxB,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,yBAAyB,EACzB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,YAAY,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,GAC9B,MAAM,gCAAgC,CAAC;AACxC,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,WAAW,EACX,QAAQ,GACT,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,mBAAmB,EACnB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGzF,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entrypoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,cAAc,GACf,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,wBAAwB,EACxB,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,yBAAyB,EACzB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,YAAY,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,GAC9B,MAAM,gCAAgC,CAAC;AACxC,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,WAAW,EACX,QAAQ,GACT,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,mBAAmB,EACnB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGzF,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/entrypoints/index.js

@@ -8,7 +8,7 @@ import {
 import {
   ApiError2,
   createHttpClient2
-} from "../index-qjeggp8w.js";
+} from "../index-h43cepag.js";
 import"../index-m38ej7e5.js";
 import {
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES2,
@@ -24,7 +24,7 @@ import {
   createUrlBuilder2,
   createUrlBuilders2,
   createScopedUrlBuilders2
-} from "../index-aaj97r4y.js";
+} from "../index-65jwqhcf.js";
 import"../index-w0eqdhyd.js";
 import {
   LiveStatePhaseSchema2,
@@ -95,6 +95,93 @@ import {
   zodIssues2,
   formatZodError2
 } from "../index-1eeqpadm.js";
+
+// src/browser/chunked-upload.ts
+function isRetryableUploadFailure(error) {
+  if (ApiError2.is(error)) {
+    if (error.status === 0)
+      return error.code === "UNKNOWN_ERROR" || error.code === "REQUEST_TIMEOUT";
+    return error.status === 429 || error.status >= 500;
+  }
+  return error instanceof TypeError;
+}
+async function uploadInChunks(config) {
+  const { file, chunkBytes, signal } = config;
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes <= 0) {
+    throw new TypeError("uploadInChunks: chunkBytes must be a positive integer");
+  }
+  if (file.size === 0)
+    throw new TypeError("uploadInChunks: the file is empty");
+  const totalBytes = file.size;
+  const chunkCount = Math.ceil(totalBytes / chunkBytes);
+  const uploadId = config.uploadId ?? crypto.randomUUID();
+  const retries = config.retries ?? 3;
+  const retryDelayMs = config.retryDelayMs ?? 1000;
+  const report = (sentBytes, index, attempt) => {
+    if (!config.onProgress)
+      return;
+    try {
+      config.onProgress({ sentBytes, totalBytes, index, chunkCount, attempt });
+    } catch {}
+  };
+  throwIfAborted(signal);
+  const opened = await repeating(() => config.init({ uploadId, totalBytes, chunkBytes, chunkCount }, { signal }), { retries, retryDelayMs, signal });
+  if (opened) {
+    report(totalBytes, chunkCount, 1);
+    return opened.finished;
+  }
+  report(0, 0, 1);
+  for (let index = 0;index < chunkCount; index += 1) {
+    throwIfAborted(signal);
+    const start = index * chunkBytes;
+    const bytes = file.slice(start, Math.min(totalBytes, start + chunkBytes));
+    await repeating((attempt) => config.chunk({ uploadId, index, bytes }, {
+      ...signal && { signal },
+      onUploadProgress: (progress) => report(start + fileShare(progress, bytes.size), index, attempt)
+    }), { retries, retryDelayMs, signal });
+    report(start + bytes.size, index + 1, 1);
+  }
+  throwIfAborted(signal);
+  return config.finalize({ uploadId }, { signal });
+}
+function fileShare(progress, partBytes) {
+  if (progress.totalBytes === 0)
+    return 0;
+  return Math.floor(partBytes * progress.sentBytes / progress.totalBytes);
+}
+async function repeating(call, {
+  retries,
+  retryDelayMs,
+  signal
+}) {
+  for (let attempt = 1;; attempt += 1) {
+    try {
+      return await call(attempt);
+    } catch (error) {
+      if (signal?.aborted || attempt > retries || !isRetryableUploadFailure(error))
+        throw error;
+      await pause(retryDelayMs * 2 ** (attempt - 1), signal);
+    }
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new ApiError2("REQUEST_ABORTED", 0, undefined, "Request was aborted");
+  }
+}
+function pause(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      reject(new ApiError2("REQUEST_ABORTED", 0, undefined, "Request was aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
 // src/browser/socket-io-trace.ts
 var realtimeRequestTraces = new WeakMap;
 function observeRealtimeRequestPhase(trace, phase) {
@@ -954,6 +1041,7 @@ export {
   rateLimited2 as rateLimited,
   resumableIterator,
   unauthorized2 as unauthorized,
+  uploadInChunks,
   withToolView2 as withToolView,
   zodIssues2 as zodIssues
 };

package/dist/entrypoints/observability.js

@@ -19,12 +19,13 @@ import {
   childSpan2,
   resolvePropagationContext2
 } from "../index-hby4qhax.js";
+import"../index-sznqf8fx.js";
 import {
   redact2,
   truncatePreview2,
   sanitizePayload2,
   measureSize2
-} from "../index-kzz6rq0w.js";
+} from "../index-e6c2spsd.js";
 import {
   runWithRequestContext2,
   getRequestContext2,

package/dist/entrypoints/react.js

@@ -2,7 +2,7 @@ import"../index-hby4qhax.js";
 import {
   ApiError2,
   isAbortLikeError
-} from "../index-qjeggp8w.js";
+} from "../index-h43cepag.js";
 import {
   isRecord
 } from "../index-9jfdm5tg.js";

package/dist/entrypoints/remote.js

@@ -1,12 +1,12 @@
 import"../index-hby4qhax.js";
 import {
   ApiError2
-} from "../index-qjeggp8w.js";
+} from "../index-h43cepag.js";
 import"../index-m38ej7e5.js";
 import"../index-r5c4fedv.js";
 import {
   createClient2
-} from "../index-aaj97r4y.js";
+} from "../index-65jwqhcf.js";
 import {
   AppError2
 } from "../index-n53mswt3.js";

package/dist/entrypoints/telegram/screens.js

@@ -9,7 +9,7 @@ import {
 } from "../../index-m38ej7e5.js";
 import {
   classifyTelegramEditRefusal
-} from "../../index-6k1svmjh.js";
+} from "../../index-e05cjgtf.js";
 import {
   checkTelegramHtml2
 } from "../../index-rz3z13e9.js";

package/dist/entrypoints/telegram.d.ts

@@ -1,11 +1,15 @@
-export { callTelegramBotApi, TELEGRAM_BOT_TOKEN_PATTERN, type TelegramBotApiCall, TelegramBotApiError, } from '../telegram/bot-api.js';
+export { callTelegramBotApi, redactTelegramBotToken, TELEGRAM_BOT_TOKEN_PATTERN, type TelegramBotApiCall, TelegramBotApiError, } from '../telegram/bot-api.js';
 export { runTelegramBroadcast, type TelegramBroadcastConfig, type TelegramBroadcastMessage, type TelegramBroadcastOutcome, type TelegramBroadcastRecipient, type TelegramBroadcastReport, type TelegramBroadcastRunOutcome, type TelegramBroadcastSend, type TelegramBroadcastSenderConfig, telegramBroadcastSender, } from '../telegram/broadcast.js';
-export { type TelegramInitData, type TelegramInitDataRefusal, type TelegramInitDataUser, type TelegramInitDataVerification, type VerifyTelegramInitDataOptions, verifyTelegramInitData, } from '../telegram/init-data.js';
+export { type TelegramInitData, type TelegramInitDataRefusal, type TelegramInitDataVerification, type VerifyTelegramInitDataOptions, verifyTelegramInitData, } from '../telegram/init-data.js';
 export { createTelegramLocalFiles, TelegramLocalFileError, type TelegramLocalFileRefusal, type TelegramLocalFiles, type TelegramLocalFilesCheck, type TelegramLocalFilesConfig, } from '../telegram/local-files.js';
-export { createTelegramOperatorChannel, type TelegramChatId, type TelegramOperatorChannel, type TelegramOperatorChannelConfig, type TelegramOperatorDedupe, type TelegramOperatorDrop, type TelegramOperatorMessage, type TelegramOperatorSenderConfig, telegramOperatorSender, } from '../telegram/operator-channel.js';
-export { classifyTelegramSendFailure, type TelegramSendFailure, type TelegramSendFailureReason, } from '../telegram/send-failure.js';
+export { createTelegramOperatorChannel, type TelegramChatId, type TelegramOperatorChannel, type TelegramOperatorChannelConfig, type TelegramOperatorDrop, type TelegramOperatorMessage, type TelegramOperatorSenderConfig, telegramOperatorSender, } from '../telegram/operator-channel.js';
+export { createTelegramOperatorDedupe, type TelegramOperatorDedupe, type TelegramOperatorDedupeVerdict, } from '../telegram/operator-dedupe.js';
+export { classifyTelegramSendFailure, TELEGRAM_SEND_FAILURE_REASONS, type TelegramSendFailure, type TelegramSendFailureReason, } from '../telegram/send-failure.js';
 export { createTelegramUpdateIntake, type TelegramUpdateEnvelope, type TelegramUpdateFailure, type TelegramUpdateIntake, type TelegramUpdateIntakeConfig, type TelegramUpdateStoreStep, } from '../telegram/update-intake.js';
 export { memoryTelegramUpdateStore, type StoredTelegramUpdate, type TelegramUpdateClaimOptions, type TelegramUpdateDueQuery, type TelegramUpdateSettlement, type TelegramUpdateState, type TelegramUpdateStore, } from '../telegram/update-store.js';
+export { checkTelegramUpdateStore } from '../telegram/update-store-check.js';
+export { type PostgresTelegramUpdateStoreConfig, postgresTelegramUpdateStore, postgresTelegramUpdateStoreSchema, type TelegramPostgresQuery, } from '../telegram/update-store-postgres.js';
 export { type SqliteTelegramUpdateStoreConfig, sqliteTelegramUpdateStore, type TelegramSqliteDatabase, } from '../telegram/update-store-sqlite.js';
+export { parseTelegramUser, type TelegramUser } from '../telegram/user.js';
 export { type ClaimTelegramWebhookConfig, checkTelegramWebhook, claimTelegramWebhook, type ReceiveTelegramWebhookOptions, receiveTelegramWebhook, TELEGRAM_WEBHOOK_NONE, type TelegramUpdateAcceptance, type TelegramWebhookClaim, TelegramWebhookClaimError, type TelegramWebhookConfig, type TelegramWebhookRefusal, type TelegramWebhookState, telegramWebhookUrl, } from '../telegram/webhook.js';
 //# sourceMappingURL=telegram.d.ts.map

package/dist/entrypoints/telegram.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"telegram.d.ts","sourceRoot":"","sources":["../../src/entrypoints/telegram.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,0BAA0B,EAC1B,KAAK,kBAAkB,EACvB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,GAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,6BAA6B,EAC7B,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,sBAAsB,GACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,2BAA2B,EAC3B,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,GAC/B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,0BAA0B,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,yBAAyB,EACzB,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,+BAA+B,EACpC,yBAAyB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,KAAK,0BAA0B,EAC/B,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,6BAA6B,EAClC,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,yBAAyB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"telegram.d.ts","sourceRoot":"","sources":["../../src/entrypoints/telegram.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC1B,KAAK,kBAAkB,EACvB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,GAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,6BAA6B,EAC7B,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,sBAAsB,GACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,4BAA4B,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,GACnC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,2BAA2B,EAC3B,6BAA6B,EAC7B,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,GAC/B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,0BAA0B,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,yBAAyB,EACzB,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EACL,KAAK,iCAAiC,EACtC,2BAA2B,EAC3B,iCAAiC,EACjC,KAAK,qBAAqB,GAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,KAAK,+BAA+B,EACpC,yBAAyB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EACL,KAAK,0BAA0B,EAC/B,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,6BAA6B,EAClC,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,yBAAyB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC"}

package/dist/entrypoints/telegram.js

@@ -1,6 +1,10 @@
 import {
+  BOT_TOKEN_SECRET
+} from "../index-sznqf8fx.js";
+import {
+  TELEGRAM_SEND_FAILURE_REASONS2,
   classifyTelegramSendFailure2
-} from "../index-6k1svmjh.js";
+} from "../index-e05cjgtf.js";
 import {
   TELEGRAM_TEXT_LIMIT2,
   truncateTelegramHtml2
@@ -11,7 +15,10 @@ import {
 } from "../index-9jfdm5tg.js";
 
 // src/telegram/bot-api.ts
-var TELEGRAM_BOT_TOKEN_PATTERN = /\d{5,}:[A-Za-z0-9_-]{30,}/;
+var TELEGRAM_BOT_TOKEN_PATTERN = BOT_TOKEN_SECRET;
+function redactTelegramBotToken(text) {
+  return text.replace(new RegExp(BOT_TOKEN_SECRET.source, "g"), "[redacted]");
+}
 var DEFAULT_API_ROOT = "https://api.telegram.org";
 
 class TelegramBotApiError extends Error {
@@ -336,9 +343,6 @@ function telegramBroadcastSender(config) {
     ...config.fetch && { fetch: config.fetch }
   });
 }
-// src/telegram/init-data.ts
-import { z as z2 } from "zod";
-
 // src/telegram/crypto.ts
 var encoder = new TextEncoder;
 async function hmacSha256(key, message) {
@@ -358,9 +362,9 @@ function digestsEqual(a, b) {
   return difference === 0;
 }
 
-// src/telegram/init-data.ts
-var encoder2 = new TextEncoder;
-var TelegramInitDataUserSchema = z2.object({
+// src/telegram/user.ts
+import { z as z2 } from "zod";
+var TelegramUserSchema = z2.object({
   id: z2.int(),
   is_bot: z2.boolean().optional(),
   first_name: z2.string(),
@@ -381,11 +385,21 @@ var TelegramInitDataUserSchema = z2.object({
   ...user.allows_write_to_pm !== undefined && { allowsWriteToPm: user.allows_write_to_pm },
   ...user.photo_url !== undefined && { photoUrl: user.photo_url }
 }));
+function parseTelegramUser(value) {
+  const parsed = TelegramUserSchema.safeParse(value);
+  return parsed.success ? parsed.data : undefined;
+}
+
+// src/telegram/init-data.ts
+var encoder2 = new TextEncoder;
 function optionalUser(raw, key) {
   const encoded = raw[key];
   if (encoded === undefined)
     return;
-  return TelegramInitDataUserSchema.parse(JSON.parse(encoded));
+  const user = parseTelegramUser(JSON.parse(encoded));
+  if (user === undefined)
+    throw new TypeError(`initData ${key} is not a Telegram user`);
+  return user;
 }
 async function verifyTelegramInitData(options) {
   if (!options.botToken)
@@ -531,42 +545,12 @@ function createTelegramLocalFiles(config) {
     }
   };
 }
-// src/telegram/operator-channel.ts
-var MASK = "[redacted]";
-function masked(text, patterns) {
-  let output = text;
-  for (const pattern of patterns) {
-    output = output.replace(new RegExp(pattern.source, `${pattern.flags.replace(/[gy]/g, "")}g`), MASK);
-  }
-  return output;
-}
-function literal(value) {
-  return new RegExp(value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-}
-function timer(milliseconds, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal.aborted)
-      return reject(signal.reason);
-    const handle = setTimeout(() => {
-      signal.removeEventListener("abort", stop);
-      resolve();
-    }, milliseconds);
-    const stop = () => {
-      clearTimeout(handle);
-      reject(signal.reason);
-    };
-    signal.addEventListener("abort", stop, { once: true });
-  });
-}
-function fitted(text) {
-  const points = Array.from(text);
-  return points.length <= TELEGRAM_TEXT_LIMIT2 ? text : `${points.slice(0, TELEGRAM_TEXT_LIMIT2 - 1).join("")}…`;
-}
+// src/telegram/operator-dedupe.ts
 function defaultFingerprint(text, topic) {
   const blanked = text.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "#").replace(/\b[a-z0-9]{20,}\b/gi, "#").replace(/\d+/g, "#");
   return `${topic ?? ""}\x00${blanked.slice(0, 300)}`;
 }
-function dedupeWindow(options) {
+function createTelegramOperatorDedupe(options = {}) {
   const windowMs = options.windowMs ?? 600000;
   const maxPerWindow = options.maxPerWindow ?? 20;
   const fingerprint = options.fingerprint ?? defaultFingerprint;
@@ -610,6 +594,38 @@ function dedupeWindow(options) {
 `) };
   };
 }
+
+// src/telegram/operator-channel.ts
+var MASK = "[redacted]";
+function masked(text, patterns) {
+  let output = text;
+  for (const pattern of patterns) {
+    output = output.replace(new RegExp(pattern.source, `${pattern.flags.replace(/[gy]/g, "")}g`), MASK);
+  }
+  return output;
+}
+function literal(value) {
+  return new RegExp(value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+}
+function timer(milliseconds, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted)
+      return reject(signal.reason);
+    const handle = setTimeout(() => {
+      signal.removeEventListener("abort", stop);
+      resolve();
+    }, milliseconds);
+    const stop = () => {
+      clearTimeout(handle);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", stop, { once: true });
+  });
+}
+function fitted(text) {
+  const points = Array.from(text);
+  return points.length <= TELEGRAM_TEXT_LIMIT2 ? text : `${points.slice(0, TELEGRAM_TEXT_LIMIT2 - 1).join("")}…`;
+}
 function createTelegramOperatorChannel(config) {
   const maxQueued = config.maxQueued ?? 200;
   const minIntervalMs = config.minIntervalMs ?? 3000;
@@ -620,7 +636,7 @@ function createTelegramOperatorChannel(config) {
     ...config.sensitivePatterns ?? [],
     ...[...config.sensitiveValues ?? []].filter((value) => value !== "").sort((left, right) => right.length - left.length).map(literal)
   ];
-  const admit = config.dedupe ? dedupeWindow(config.dedupe) : undefined;
+  const admit = config.dedupe ? createTelegramOperatorDedupe(config.dedupe) : undefined;
   const queue = [];
   const idle = new Set;
   let lifetime = new AbortController;
@@ -809,6 +825,9 @@ function parsed(body) {
     return;
   }
 }
+function handlerError(error) {
+  return error instanceof Error && error.name === "BotError" && "ctx" in error && "error" in error ? error.error : error;
+}
 function positive(name, value) {
   if (!Number.isSafeInteger(value) || value < 1) {
     throw new RangeError(`[stitchkit] telegram update intake: ${name} is a positive integer`);
@@ -862,7 +881,8 @@ function createTelegramUpdateIntake(config) {
     try {
       await config.handle(transportResult(update));
       settlement = { state: "completed", at: now() };
-    } catch (error) {
+    } catch (thrown) {
+      const error = handlerError(thrown);
       const delay = number >= maxAttempts ? false : retry(error, number);
       const message = error instanceof Error ? error.message : String(error);
       settlement = delay === false ? { state: "abandoned", at: now(), error: message } : { state: "failed", at: now(), retryAt: now() + delay, error: message };
@@ -1022,9 +1042,210 @@ function memoryTelegramUpdateStore() {
     }
   };
 }
-// src/telegram/update-store-sqlite.ts
+// src/telegram/update-store-check.ts
+function same(actual, expected) {
+  return JSON.stringify(actual) === JSON.stringify(expected);
+}
+var claim = { maxAttempts: 2 };
+var RULES = {
+  "one record per update_id": async (store, violated) => {
+    if (!await store.add({ updateId: 7, body: "b", receivedAt: 0 }))
+      violated("add of a new update returned false");
+    if (await store.add({ updateId: 7, body: "other", receivedAt: 1 }))
+      violated("add of a recorded update_id returned true");
+  },
+  "a live lease is not taken, a lapsed one is": async (store, violated) => {
+    await store.add({ updateId: 7, body: "b", receivedAt: 0 });
+    if (await store.claim(7, { ...claim, now: 10, leaseUntil: 100 }) !== 1)
+      violated("the first claim was not attempt 1");
+    if (await store.claim(7, { ...claim, now: 50, leaseUntil: 150 }) !== undefined)
+      violated("a claim took an update under a live lease");
+    if (!same(await store.due({ now: 50, pendingBefore: 50, limit: 10 }), []))
+      violated("due listed an update under a live lease");
+    if (!same(await store.due({ now: 101, pendingBefore: 0, limit: 10 }), [
+      { updateId: 7, body: "b" }
+    ]))
+      violated("due did not list an update whose lease lapsed, with its body");
+    if (await store.claim(7, { ...claim, now: 101, leaseUntil: 200 }) !== 2)
+      violated("a lapsed lease was not taken as attempt 2");
+  },
+  "only the attempt holding the update renews or settles it": async (store, violated) => {
+    await store.add({ updateId: 1, body: "b", receivedAt: 0 });
+    await store.claim(1, { ...claim, now: 0, leaseUntil: 10 });
+    await store.claim(1, { ...claim, now: 11, leaseUntil: 50 });
+    if (await store.renew(1, 1, 500))
+      violated("an attempt that lost its lease renewed it");
+    if (!await store.renew(1, 2, 60))
+      violated("the holding attempt could not renew");
+    await store.settle(1, 1, { state: "completed", at: 20 });
+    if ((await store.due({ now: 61, pendingBefore: 0, limit: 10 })).length !== 1)
+      violated("an attempt that lost its lease settled the update");
+    await store.settle(1, 2, { state: "completed", at: 30 });
+    if (!same(await store.due({ now: 1000, pendingBefore: 1000, limit: 10 }), []))
+      violated("a completed update is still due");
+  },
+  "a failed update is due at its retry, spent attempts abandon it": async (store, violated) => {
+    await store.add({ updateId: 2, body: "b", receivedAt: 0 });
+    await store.add({ updateId: 1, body: "a", receivedAt: 5 });
+    await store.claim(2, { ...claim, now: 0, leaseUntil: 10 });
+    await store.settle(2, 1, { state: "failed", at: 1, retryAt: 30, error: "x" });
+    if (!same(await store.due({ now: 29, pendingBefore: 0, limit: 10 }), []))
+      violated("a failed update was due before its retry, or a pending one before its grace");
+    const due = await store.due({ now: 30, pendingBefore: 5, limit: 10 });
+    if (!same(due.map((row) => row.updateId), [1, 2]))
+      violated("due did not list a retry and a pending update in update_id order");
+    if ((await store.due({ now: 30, pendingBefore: 5, limit: 1 })).length !== 1)
+      violated("due ignored its limit");
+    await store.claim(2, { ...claim, now: 30, leaseUntil: 40 });
+    await store.settle(2, 2, { state: "failed", at: 31, retryAt: 35, error: "x" });
+    if (await store.claim(2, { ...claim, now: 36, leaseUntil: 50 }) !== undefined)
+      violated("an update past maxAttempts was claimed");
+    if (!same(await store.due({ now: 100, pendingBefore: 0, limit: 10 }), []))
+      violated("an update past maxAttempts was not abandoned");
+  },
+  "settled updates are forgotten after they are pruned": async (store, violated) => {
+    await store.add({ updateId: 3, body: "b", receivedAt: 0 });
+    await store.claim(3, { ...claim, now: 0, leaseUntil: 10 });
+    await store.settle(3, 1, { state: "abandoned", at: 36, error: "x" });
+    await store.add({ updateId: 4, body: "b", receivedAt: 0 });
+    if (await store.prune(36) !== 0)
+      violated("prune forgot an update settled at its bound");
+    if (await store.prune(37) !== 1)
+      violated("prune did not forget exactly the settled update before its bound");
+    if (!await store.add({ updateId: 3, body: "b", receivedAt: 40 }))
+      violated("a pruned update_id could not be recorded again");
+    if (await store.add({ updateId: 4, body: "b", receivedAt: 40 }))
+      violated("prune forgot an update that was never settled");
+  },
+  "of concurrent claims exactly one takes the update": async (store, violated) => {
+    await store.add({ updateId: 9, body: "b", receivedAt: 0 });
+    const taken = await Promise.all(Array.from({ length: 8 }, () => store.claim(9, { maxAttempts: 5, now: 1, leaseUntil: 100 })));
+    if (taken.filter((attempt) => attempt !== undefined).length !== 1)
+      violated(`${taken.filter((attempt) => attempt !== undefined).length} of 8 concurrent claims took one update`);
+  }
+};
+async function checkTelegramUpdateStore(make) {
+  const violations = [];
+  for (const [name, rule] of Object.entries(RULES)) {
+    try {
+      await rule(await make(), (what) => violations.push(`${name}: ${what}`));
+    } catch (error) {
+      violations.push(`${name}: threw ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return violations;
+}
+// src/telegram/update-store-postgres.ts
 var TABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
-var CLAIMABLE = `(state = 'pending' OR (state = 'failed' AND due_at <= ?1)
+function checkedTable(table) {
+  if (!TABLE_NAME.test(table)) {
+    throw new TypeError("[stitchkit] telegram update store: a table name is [A-Za-z_][A-Za-z0-9_]*");
+  }
+  return table;
+}
+function postgresTelegramUpdateStoreSchema(table = "telegram_updates") {
+  const name = checkedTable(table);
+  return `CREATE TABLE IF NOT EXISTS ${name} (
+  update_id BIGINT PRIMARY KEY,
+  body TEXT NOT NULL,
+  state TEXT NOT NULL,
+  attempts INTEGER NOT NULL,
+  due_at BIGINT NOT NULL,
+  received_at BIGINT NOT NULL,
+  settled_at BIGINT,
+  error TEXT
+);
+CREATE INDEX IF NOT EXISTS ${name}_due ON ${name} (state, due_at);`;
+}
+var CLAIMABLE = `(state = 'pending' OR (state = 'failed' AND due_at <= $1::bigint)
+  OR (state = 'processing' AND due_at < $1::bigint))`;
+function integer(value) {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "bigint" || typeof value === "string" && /^-?\d+$/.test(value)) {
+    return Number(value);
+  }
+  return;
+}
+function field(row, name) {
+  return typeof row === "object" && row !== null && name in row ? Reflect.get(row, name) : undefined;
+}
+function postgresTelegramUpdateStore(config) {
+  const table = checkedTable(config.table ?? "telegram_updates");
+  const { query } = config;
+  let ready;
+  const run = async (text, parameters) => {
+    if (config.createTable !== false) {
+      ready ??= postgresTelegramUpdateStoreSchema(table).split(";").map((statement) => statement.trim()).filter((statement) => statement !== "").reduce((previous, statement) => previous.then(() => query(statement, [])), Promise.resolve()).then(() => {
+        return;
+      }, (error) => {
+        ready = undefined;
+        throw error;
+      });
+      await ready;
+    }
+    return query(text, parameters);
+  };
+  return {
+    async add(update) {
+      const rows = await run(`INSERT INTO ${table} (update_id, body, state, attempts, due_at, received_at)
+         VALUES ($1::bigint, $2::text, 'pending', 0, $3::bigint, $3::bigint)
+         ON CONFLICT (update_id) DO NOTHING RETURNING update_id`, [update.updateId, update.body, update.receivedAt]);
+      return rows.length > 0;
+    },
+    async claim(updateId, options) {
+      const [row] = await run(`UPDATE ${table} SET state = 'processing', attempts = attempts + 1,
+           due_at = $2::bigint, error = NULL
+         WHERE update_id = $3::bigint AND attempts < $4::integer AND ${CLAIMABLE}
+         RETURNING attempts`, [options.now, options.leaseUntil, updateId, options.maxAttempts]);
+      const attempts = integer(field(row, "attempts"));
+      if (attempts !== undefined)
+        return attempts;
+      await run(`UPDATE ${table} SET state = 'abandoned', settled_at = $1::bigint, error = 'attempts spent'
+         WHERE update_id = $2::bigint AND attempts >= $3::integer AND ${CLAIMABLE}
+         RETURNING update_id`, [options.now, updateId, options.maxAttempts]);
+      return;
+    },
+    async renew(updateId, attempt, leaseUntil) {
+      const rows = await run(`UPDATE ${table} SET due_at = $1::bigint
+         WHERE update_id = $2::bigint AND attempts = $3::integer AND state = 'processing'
+         RETURNING update_id`, [leaseUntil, updateId, attempt]);
+      return rows.length > 0;
+    },
+    async settle(updateId, attempt, settlement) {
+      await run(`UPDATE ${table} SET state = $1::text, due_at = COALESCE($2::bigint, due_at),
+           settled_at = $3::bigint, error = $4::text
+         WHERE update_id = $5::bigint AND attempts = $6::integer AND state = 'processing'
+         RETURNING update_id`, [
+        settlement.state,
+        settlement.state === "failed" ? settlement.retryAt : null,
+        settlement.state === "failed" ? null : settlement.at,
+        settlement.state === "completed" ? null : settlement.error,
+        updateId,
+        attempt
+      ]);
+    },
+    async due(options) {
+      const rows = await run(`SELECT update_id, body FROM ${table}
+         WHERE (state = 'pending' AND received_at <= $2::bigint)
+           OR (state <> 'pending' AND ${CLAIMABLE})
+         ORDER BY update_id LIMIT $3::integer`, [options.now, options.pendingBefore, options.limit]);
+      return rows.flatMap((row) => {
+        const updateId = integer(field(row, "update_id"));
+        const body = field(row, "body");
+        return updateId !== undefined && typeof body === "string" ? [{ updateId, body }] : [];
+      });
+    },
+    async prune(before) {
+      const rows = await run(`DELETE FROM ${table} WHERE state IN ('completed', 'abandoned') AND settled_at < $1::bigint
+         RETURNING update_id`, [before]);
+      return rows.length;
+    }
+  };
+}
+// src/telegram/update-store-sqlite.ts
+var TABLE_NAME2 = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+var CLAIMABLE2 = `(state = 'pending' OR (state = 'failed' AND due_at <= ?1)
   OR (state = 'processing' AND due_at < ?1))`;
 function rowOf(row) {
   if (typeof row !== "object" || row === null)
@@ -1035,7 +1256,7 @@ function rowOf(row) {
 }
 function sqliteTelegramUpdateStore(config) {
   const table = config.table ?? "telegram_updates";
-  if (!TABLE_NAME.test(table)) {
+  if (!TABLE_NAME2.test(table)) {
     throw new TypeError("[stitchkit] telegram update store: a table name is [A-Za-z_][A-Za-z0-9_]*");
   }
   const database = config.database;
@@ -1053,14 +1274,14 @@ function sqliteTelegramUpdateStore(config) {
   const insert = database.prepare(`INSERT OR IGNORE INTO ${table} (update_id, body, state, attempts, due_at, received_at)
      VALUES (?1, ?2, 'pending', 0, ?3, ?3)`);
   const take = database.prepare(`UPDATE ${table} SET state = 'processing', attempts = attempts + 1, due_at = ?2, error = NULL
-     WHERE update_id = ?3 AND attempts < ?4 AND ${CLAIMABLE} RETURNING attempts`);
+     WHERE update_id = ?3 AND attempts < ?4 AND ${CLAIMABLE2} RETURNING attempts`);
   const spend = database.prepare(`UPDATE ${table} SET state = 'abandoned', settled_at = ?1, error = 'attempts spent'
-     WHERE update_id = ?2 AND attempts >= ?3 AND ${CLAIMABLE}`);
+     WHERE update_id = ?2 AND attempts >= ?3 AND ${CLAIMABLE2}`);
   const renew = database.prepare(`UPDATE ${table} SET due_at = ?1 WHERE update_id = ?2 AND attempts = ?3 AND state = 'processing'`);
   const settle = database.prepare(`UPDATE ${table} SET state = ?1, due_at = COALESCE(?2, due_at), settled_at = ?3, error = ?4
      WHERE update_id = ?5 AND attempts = ?6 AND state = 'processing'`);
   const due = database.prepare(`SELECT update_id, body FROM ${table}
-     WHERE (state = 'pending' AND received_at <= ?2) OR (state <> 'pending' AND ${CLAIMABLE})
+     WHERE (state = 'pending' AND received_at <= ?2) OR (state <> 'pending' AND ${CLAIMABLE2})
      ORDER BY update_id LIMIT ?3`);
   const prune = database.prepare(`DELETE FROM ${table} WHERE state IN ('completed', 'abandoned') AND settled_at < ?1`);
   return {
@@ -1199,19 +1420,26 @@ async function receiveTelegramWebhook(request, options) {
 }
 export {
   TELEGRAM_BOT_TOKEN_PATTERN,
+  TELEGRAM_SEND_FAILURE_REASONS2 as TELEGRAM_SEND_FAILURE_REASONS,
   TELEGRAM_WEBHOOK_NONE,
   TelegramBotApiError,
   TelegramLocalFileError,
   TelegramWebhookClaimError,
   callTelegramBotApi,
+  checkTelegramUpdateStore,
   checkTelegramWebhook,
   claimTelegramWebhook,
   classifyTelegramSendFailure2 as classifyTelegramSendFailure,
   createTelegramLocalFiles,
   createTelegramOperatorChannel,
+  createTelegramOperatorDedupe,
   createTelegramUpdateIntake,
   memoryTelegramUpdateStore,
+  parseTelegramUser,
+  postgresTelegramUpdateStore,
+  postgresTelegramUpdateStoreSchema,
   receiveTelegramWebhook,
+  redactTelegramBotToken,
   runTelegramBroadcast,
   sqliteTelegramUpdateStore,
   telegramBroadcastSender,