@llblab/pi-telegram 0.45.11 → 0.47.0

package/dist/lib/voice.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Voice Domain
+ * Zones: telegram, voice
+ *
+ * This module is the single owner of all Voice-specific coordination logic:
+ * - Voice reply policy (mirror / voice / manual) via getTelegramVoiceReplyMode()
+ * - Voice turn tagging (voiceReplyPreferred / voiceReplyRequired)
+ * - Voice-specific prompt contributions for the LLM
+ * - Voice synthesis provider registry (registration + policy/prompt hooks)
+ * - Voice markup parsing (planTelegramVoiceReply + helpers)
+ * - Voice suppression helpers (isVoiceTurn, shouldSuppressPreviewForVoice)
+ *
+ * Separation of concerns:
+ * - All decision logic and domain rules live here.
+ * - Actual delivery (sending the audio via Telegram) stays in outbound.ts.
+ *
+ * Keeps voice policy, turn tagging, prompt contributions, and markup helpers
+ * out of the queue, preview, turn-building, and delivery domains.
+ */
+export type TelegramVoiceReplyMode = "manual" | "mirror" | "always";
+export type TelegramVoiceSynthesisProviderResult = string | undefined;
+export interface TelegramVoiceTurnView {
+    voiceReplyPreferred?: boolean;
+    voiceReplyRequired?: boolean;
+    hasVoiceInput?: boolean;
+    userText?: string;
+}
+export interface TelegramVoiceSynthesisProvider {
+    (text: string, options?: {
+        lang?: string;
+        rate?: string;
+    }): Promise<TelegramVoiceSynthesisProviderResult>;
+    getVoicePolicy?: () => {
+        replyMode?: TelegramVoiceReplyMode;
+    };
+    getVoicePromptContribution?: (view: TelegramVoiceTurnView) => string | undefined;
+}
+export type TelegramVoiceTranscriptionProviderResult = string | {
+    text: string;
+    language?: string;
+} | undefined;
+export interface TelegramVoiceTranscriptionFile {
+    path: string;
+    fileName?: string;
+    mimeType?: string;
+    kind?: string;
+}
+export interface TelegramVoiceTranscriptionProvider {
+    (file: TelegramVoiceTranscriptionFile, options?: {
+        language?: string;
+    }): Promise<TelegramVoiceTranscriptionProviderResult>;
+}
+/**
+ * Register a high-level Telegram voice synthesis provider.
+ *
+ * Stable public API callers must pass a stable `options.id` so diagnostics,
+ * replacement, and cleanup can identify the provider. Omitted ids remain a
+ * compatibility path for pre-matrix callers and receive generated session-local
+ * ids.
+ */
+export declare function registerTelegramVoiceSynthesisProvider(provider: TelegramVoiceSynthesisProvider | ((text: string, options?: {
+    lang?: string;
+    rate?: string;
+}) => Promise<TelegramVoiceSynthesisProviderResult>), options?: {
+    id?: string;
+}): () => void;
+export declare function getTelegramVoiceSynthesisProviders(): TelegramVoiceSynthesisProvider[];
+export declare function hasTelegramVoiceSynthesisProvider(): boolean;
+export declare function clearTelegramVoiceSynthesisProviders(): void;
+/**
+ * Register a high-level Telegram voice transcription provider.
+ *
+ * Stable public API callers must pass a stable `options.id`. Omitted ids remain
+ * a compatibility path for pre-matrix callers and receive generated
+ * session-local ids.
+ */
+export declare function registerTelegramVoiceTranscriptionProvider(provider: TelegramVoiceTranscriptionProvider, options?: {
+    id?: string;
+}): () => void;
+export declare function getTelegramVoiceTranscriptionProviders(): TelegramVoiceTranscriptionProvider[];
+export declare function hasTelegramVoiceTranscriptionProvider(): boolean;
+export declare function clearTelegramVoiceTranscriptionProviders(): void;
+export declare const TELEGRAM_VOICE_REPLY_MODES: readonly ["manual", "mirror", "always"];
+/**
+ * Returns the active voice reply mode for the current session.
+ *
+ * Pi-telegram owns reply-mode policy through telegram.json. If
+ * config.voice.replyMode is missing, invalid, or legacy `hidden`, the effective
+ * mode is manual.
+ */
+export declare function getTelegramVoiceReplyMode(config?: {
+    voice?: {
+        replyMode?: string;
+    };
+}): TelegramVoiceReplyMode;
+/** Small helper to compute the two voice flags from mode + hasVoiceFile */
+export declare function computeVoiceTurnFlags(voiceReplyMode: TelegramVoiceReplyMode | undefined, hasVoiceFile: boolean): {
+    voiceReplyPreferred: boolean;
+    voiceReplyRequired: boolean;
+};
+/** Returns true if the given turn is tagged as a voice turn */
+export declare function isVoiceTurn(turn: {
+    voiceReplyPreferred?: boolean;
+    voiceReplyRequired?: boolean;
+} | null | undefined): boolean;
+export declare function computeVoicePromptContribution(voiceReplyMode: TelegramVoiceReplyMode | undefined, files: Array<{
+    kind?: string;
+}>, rawText: string): string | undefined;
+/**
+ * Returns true if the current turn should not show a text preview
+ * (e.g. because it's a voice reply).
+ */
+export declare function shouldSuppressPreviewForVoice(turn: {
+    voiceReplyPreferred?: boolean;
+    voiceReplyRequired?: boolean;
+} | null | undefined): boolean;
+export { normalizeMarkdownAfterVoiceExtraction, planTelegramVoiceReply, stripTelegramCommentMarkupForDelivery, stripTelegramCommentMarkupForPreview, stripTelegramVoiceMarkupForPreview, } from "./outbound-markup.ts";

package/dist/lib/voice.js

@@ -0,0 +1,174 @@
+/**
+ * Voice Domain
+ * Zones: telegram, voice
+ *
+ * This module is the single owner of all Voice-specific coordination logic:
+ * - Voice reply policy (mirror / voice / manual) via getTelegramVoiceReplyMode()
+ * - Voice turn tagging (voiceReplyPreferred / voiceReplyRequired)
+ * - Voice-specific prompt contributions for the LLM
+ * - Voice synthesis provider registry (registration + policy/prompt hooks)
+ * - Voice markup parsing (planTelegramVoiceReply + helpers)
+ * - Voice suppression helpers (isVoiceTurn, shouldSuppressPreviewForVoice)
+ *
+ * Separation of concerns:
+ * - All decision logic and domain rules live here.
+ * - Actual delivery (sending the audio via Telegram) stays in outbound.ts.
+ *
+ * Keeps voice policy, turn tagging, prompt contributions, and markup helpers
+ * out of the queue, preview, turn-building, and delivery domains.
+ */
+const VOICE_SYNTHESIS_PROVIDER_REGISTRY_KEY = "__piTelegramVoiceSynthesisProviders__";
+const VOICE_TRANSCRIPTION_PROVIDER_REGISTRY_KEY = "__piTelegramVoiceTranscriptionProviders__";
+let nextGeneratedVoiceSynthesisProviderId = 0;
+let nextGeneratedVoiceTranscriptionProviderId = 0;
+function getNextAvailableProviderId(registry, prefix, nextId) {
+    let id;
+    do {
+        id = `${prefix}-${nextId()}`;
+    } while (registry.has(id));
+    return id;
+}
+// --- Voice Synthesis Provider Registry ---
+function getOrCreateVoiceSynthesisProviderRegistry() {
+    const existing = globalThis[VOICE_SYNTHESIS_PROVIDER_REGISTRY_KEY];
+    if (existing instanceof Map)
+        return existing;
+    const registry = new Map();
+    globalThis[VOICE_SYNTHESIS_PROVIDER_REGISTRY_KEY] = registry;
+    return registry;
+}
+/**
+ * Register a high-level Telegram voice synthesis provider.
+ *
+ * Stable public API callers must pass a stable `options.id` so diagnostics,
+ * replacement, and cleanup can identify the provider. Omitted ids remain a
+ * compatibility path for pre-matrix callers and receive generated session-local
+ * ids.
+ */
+export function registerTelegramVoiceSynthesisProvider(provider, options) {
+    const registry = getOrCreateVoiceSynthesisProviderRegistry();
+    const id = options?.id ??
+        getNextAvailableProviderId(registry, "voice-synthesis-provider", () => nextGeneratedVoiceSynthesisProviderId++);
+    const normalized = typeof provider === "function"
+        ? Object.assign((text, options) => provider(text, options), {
+            getVoicePolicy: provider
+                .getVoicePolicy,
+            getVoicePromptContribution: provider.getVoicePromptContribution,
+        })
+        : provider;
+    registry.set(id, normalized);
+    return () => {
+        if (registry.get(id) === normalized)
+            registry.delete(id);
+    };
+}
+export function getTelegramVoiceSynthesisProviders() {
+    return Array.from(getOrCreateVoiceSynthesisProviderRegistry().values());
+}
+export function hasTelegramVoiceSynthesisProvider() {
+    return getOrCreateVoiceSynthesisProviderRegistry().size > 0;
+}
+export function clearTelegramVoiceSynthesisProviders() {
+    getOrCreateVoiceSynthesisProviderRegistry().clear();
+}
+function getOrCreateVoiceTranscriptionProviderRegistry() {
+    const existing = globalThis[VOICE_TRANSCRIPTION_PROVIDER_REGISTRY_KEY];
+    if (existing instanceof Map) {
+        return existing;
+    }
+    const registry = new Map();
+    globalThis[VOICE_TRANSCRIPTION_PROVIDER_REGISTRY_KEY] = registry;
+    return registry;
+}
+/**
+ * Register a high-level Telegram voice transcription provider.
+ *
+ * Stable public API callers must pass a stable `options.id`. Omitted ids remain
+ * a compatibility path for pre-matrix callers and receive generated
+ * session-local ids.
+ */
+export function registerTelegramVoiceTranscriptionProvider(provider, options) {
+    const registry = getOrCreateVoiceTranscriptionProviderRegistry();
+    const id = options?.id ??
+        getNextAvailableProviderId(registry, "voice-transcription-provider", () => nextGeneratedVoiceTranscriptionProviderId++);
+    registry.set(id, provider);
+    return () => {
+        if (registry.get(id) === provider)
+            registry.delete(id);
+    };
+}
+export function getTelegramVoiceTranscriptionProviders() {
+    return Array.from(getOrCreateVoiceTranscriptionProviderRegistry().values());
+}
+export function hasTelegramVoiceTranscriptionProvider() {
+    return getOrCreateVoiceTranscriptionProviderRegistry().size > 0;
+}
+export function clearTelegramVoiceTranscriptionProviders() {
+    getOrCreateVoiceTranscriptionProviderRegistry().clear();
+}
+// --- Voice Reply Modes ---
+export const TELEGRAM_VOICE_REPLY_MODES = [
+    "manual",
+    "mirror",
+    "always",
+];
+/**
+ * Returns the active voice reply mode for the current session.
+ *
+ * Pi-telegram owns reply-mode policy through telegram.json. If
+ * config.voice.replyMode is missing, invalid, or legacy `hidden`, the effective
+ * mode is manual.
+ */
+export function getTelegramVoiceReplyMode(config) {
+    const configMode = config?.voice?.replyMode;
+    if (configMode === "mirror" || configMode === "always")
+        return configMode;
+    return "manual";
+}
+// --- Voice Turn Helpers ---
+/** Small helper to compute the two voice flags from mode + hasVoiceFile */
+export function computeVoiceTurnFlags(voiceReplyMode, hasVoiceFile) {
+    return {
+        voiceReplyPreferred: hasVoiceFile && voiceReplyMode === "mirror",
+        voiceReplyRequired: voiceReplyMode === "always",
+    };
+}
+/** Returns true if the given turn is tagged as a voice turn */
+export function isVoiceTurn(turn) {
+    return !!(turn?.voiceReplyPreferred || turn?.voiceReplyRequired);
+}
+// --- Voice Prompt Contribution ---
+export function computeVoicePromptContribution(voiceReplyMode, files, rawText) {
+    const hasVoiceFile = files.some((f) => f.kind === "voice" || f.kind === "audio");
+    const isVoiceTagged = voiceReplyMode === "always" ||
+        (voiceReplyMode === "mirror" && hasVoiceFile);
+    if (!isVoiceTagged)
+        return undefined;
+    const view = {
+        ...computeVoiceTurnFlags(voiceReplyMode, hasVoiceFile),
+        hasVoiceInput: hasVoiceFile,
+        userText: rawText,
+    };
+    // Let the voice synthesis provider supply additional instructions for the LLM when in voice mode.
+    // When multiple providers are registered, the first one (in registration order)
+    // that returns a non-empty string wins.
+    for (const provider of getTelegramVoiceSynthesisProviders()) {
+        if (typeof provider.getVoicePromptContribution === "function") {
+            const contribution = provider.getVoicePromptContribution(view);
+            if (contribution?.trim()) {
+                return contribution.trim();
+            }
+        }
+    }
+    return undefined;
+}
+// --- Preview Suppression ---
+/**
+ * Returns true if the current turn should not show a text preview
+ * (e.g. because it's a voice reply).
+ */
+export function shouldSuppressPreviewForVoice(turn) {
+    return !!(turn?.voiceReplyPreferred || turn?.voiceReplyRequired);
+}
+// --- Outbound Markup Re-Exports ---
+export { normalizeMarkdownAfterVoiceExtraction, planTelegramVoiceReply, stripTelegramCommentMarkupForDelivery, stripTelegramCommentMarkupForPreview, stripTelegramVoiceMarkupForPreview, } from "./outbound-markup.js";

package/dist/lib/workspace-admission.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Durable Telegram Workspace admission and retirement fencing
+ * Zones: telegram workspace identity, filesystem authority, process recovery
+ * Owns profile-scoped admission leases, destructive fences, and deletion permits
+ * Excludes journal/API operations, retirement policy, and binding persistence
+ */
+import { type PathLike } from "node:fs";
+import { type TelegramProcessLiveness } from "./bus.ts";
+import type { TelegramTarget } from "./target.ts";
+export interface TelegramWorkspaceAdmissionOwner {
+    processId: number;
+    processBirthId: string;
+}
+export type TelegramWorkspaceAdmissionScope = {
+    kind: "target";
+    target: TelegramTarget & {
+        threadId: number;
+    };
+} | {
+    kind: "chat";
+    chatId: number;
+} | {
+    kind: "profile";
+};
+export interface TelegramWorkspaceAdmissionLease {
+    operationId: string;
+    operationKind: string;
+    profileKey: string;
+    scope: TelegramWorkspaceAdmissionScope;
+    owner: TelegramWorkspaceAdmissionOwner;
+    acquiredAtMs: number;
+}
+export type TelegramWorkspaceDestructiveFenceKind = "pressure-retirement" | "manual-thread-cleanup" | "journal-writer-closure";
+export type TelegramWorkspaceDeletionFenceKind = Exclude<TelegramWorkspaceDestructiveFenceKind, "journal-writer-closure">;
+export interface TelegramWorkspaceJournalWriterClosureFence {
+    destructiveKind: "journal-writer-closure";
+    phase: "fenced";
+    operationId: string;
+    profileKey: string;
+    recoveryKey: string;
+    owner: TelegramWorkspaceAdmissionOwner;
+    requestedAtMs: number;
+    acquiredAtMs: number;
+}
+export declare function normalizeTelegramWorkspaceJournalWriterClosureFence(value: unknown, profileKey: string): TelegramWorkspaceJournalWriterClosureFence | undefined;
+export interface TelegramWorkspaceJournalWriterProtocolMode {
+    version: 1;
+    protocol: "custody-v3";
+    profileKey: string;
+    recoveryKey: string;
+    startupAuthorityId: string;
+    closureOperationId: string;
+    writerInventorySha256: string;
+    installedBy: TelegramWorkspaceAdmissionOwner;
+    installedAtMs: number;
+}
+export declare function normalizeTelegramWorkspaceJournalWriterProtocolMode(value: unknown, profileKey: string): TelegramWorkspaceJournalWriterProtocolMode | undefined;
+interface TelegramWorkspaceRetirementFenceBase {
+    destructiveKind?: TelegramWorkspaceDeletionFenceKind;
+    operationId: string;
+    retirementIntentId: string;
+    profileKey: string;
+    bindingKey: string;
+    slot: string;
+    target: TelegramTarget & {
+        threadId: number;
+    };
+    leaderEpoch: number | string;
+    retirementRequestedAtMs: number;
+    owner: TelegramWorkspaceAdmissionOwner;
+    acquiredAtMs: number;
+}
+export type TelegramWorkspaceRetirementFence = (TelegramWorkspaceRetirementFenceBase & {
+    phase: "fenced";
+}) | (TelegramWorkspaceRetirementFenceBase & {
+    phase: "deletion-issued";
+    deletionIssuedAtMs: number;
+}) | (TelegramWorkspaceRetirementFenceBase & {
+    phase: "commit-ready";
+    absenceConfirmedAtMs: number;
+    deletionIssuedAtMs?: number;
+});
+export type TelegramWorkspaceDestructiveFence = TelegramWorkspaceRetirementFence | TelegramWorkspaceJournalWriterClosureFence;
+export declare function isTelegramWorkspaceRetirementFence(fence: TelegramWorkspaceDestructiveFence): fence is TelegramWorkspaceRetirementFence;
+export interface TelegramWorkspaceDeletionPermit {
+    readonly destructiveKind?: TelegramWorkspaceDeletionFenceKind;
+    readonly operationId: string;
+    readonly retirementIntentId: string;
+    readonly profileKey: string;
+    readonly bindingKey: string;
+    readonly slot: string;
+    readonly target: TelegramTarget & {
+        threadId: number;
+    };
+    readonly leaderEpoch: number | string;
+    readonly issuedAtMs: number;
+}
+export type TelegramWorkspaceAdmissionBlockReason = "retirement-fenced" | "admission-active" | "retirement-active";
+export type TelegramWorkspaceAdmissionAcquireResult = {
+    kind: "acquired";
+    lease: TelegramWorkspaceAdmissionLease;
+    resumed: boolean;
+} | {
+    kind: "blocked";
+    reason: "retirement-fenced";
+};
+export type TelegramWorkspaceRetirementFenceAcquireResult = {
+    kind: "acquired";
+    fence: TelegramWorkspaceRetirementFence;
+    resumed: boolean;
+} | {
+    kind: "blocked";
+    reason: "admission-active" | "retirement-active";
+};
+export type TelegramWorkspaceJournalWriterProtocolInstallResult = {
+    mode: TelegramWorkspaceJournalWriterProtocolMode;
+    resumed: boolean;
+};
+export type TelegramWorkspaceJournalWriterClosureAcquireResult = {
+    kind: "acquired";
+    fence: TelegramWorkspaceJournalWriterClosureFence;
+    resumed: boolean;
+} | {
+    kind: "blocked";
+    reason: "admission-active" | "retirement-active";
+};
+export type TelegramWorkspaceDeletionPermitResult = {
+    kind: "issued";
+    fence: TelegramWorkspaceRetirementFence;
+    permit: TelegramWorkspaceDeletionPermit;
+} | {
+    kind: "already-issued";
+    fence: TelegramWorkspaceRetirementFence;
+};
+export interface TelegramWorkspaceAdmissionLedgerSnapshot {
+    profileKey: string;
+    leases: TelegramWorkspaceAdmissionLease[];
+    fence?: TelegramWorkspaceDestructiveFence;
+    writerProtocolMode?: TelegramWorkspaceJournalWriterProtocolMode;
+}
+export type TelegramWorkspaceAdmissionPublicationBoundary = "before-write" | "after-write-before-rename";
+export interface TelegramWorkspaceAdmissionLedgerOptions {
+    path: string;
+    profileKey: string;
+    owner: TelegramWorkspaceAdmissionOwner;
+    getNowMs?: () => number;
+    getProcessLiveness?: (owner: TelegramWorkspaceAdmissionOwner) => TelegramProcessLiveness;
+    publishRename?: (sourcePath: PathLike, destinationPath: PathLike) => void;
+    onPublicationBoundary?: (boundary: TelegramWorkspaceAdmissionPublicationBoundary, path: string) => void;
+    authorizeJournalWriterProtocolClosure?: (input: {
+        mode: TelegramWorkspaceJournalWriterProtocolMode;
+        closure: TelegramWorkspaceJournalWriterClosureFence;
+    }) => boolean;
+}
+export declare class TelegramWorkspaceAdmissionError extends Error {
+    readonly code: "invalid-input" | "invalid-state" | "state-unavailable" | "authority-changed" | "admission-blocked" | "publication-unknown";
+    constructor(code: TelegramWorkspaceAdmissionError["code"], message: string, options?: ErrorOptions);
+}
+export interface TelegramWorkspaceAdmissionLedger {
+    getProfileKey: () => string;
+    getOwner: () => TelegramWorkspaceAdmissionOwner;
+    listReservedSlots: () => string[];
+    read: () => TelegramWorkspaceAdmissionLedgerSnapshot;
+    acquireAdmission: (input: {
+        operationId: string;
+        operationKind: string;
+        scope: TelegramWorkspaceAdmissionScope;
+    }) => TelegramWorkspaceAdmissionAcquireResult;
+    releaseAdmission: (expected: TelegramWorkspaceAdmissionLease) => boolean;
+    acquireJournalWriterClosure: (input: {
+        operationId: string;
+        recoveryKey: string;
+        requestedAtMs: number;
+    }) => TelegramWorkspaceJournalWriterClosureAcquireResult;
+    releaseJournalWriterClosure: (expected: TelegramWorkspaceJournalWriterClosureFence) => boolean;
+    installJournalWriterProtocolMode: (expected: TelegramWorkspaceJournalWriterClosureFence, input: {
+        startupAuthorityId: string;
+        writerInventorySha256: string;
+    }) => TelegramWorkspaceJournalWriterProtocolInstallResult;
+    acquireJournalWriterAdmission: (input: {
+        operationId: string;
+        recoveryKey: string;
+        startupAuthorityId: string;
+        closureOperationId: string;
+        writerInventorySha256: string;
+    }) => TelegramWorkspaceAdmissionAcquireResult;
+    acquireRetirementFence: (input: {
+        operationId: string;
+        retirementIntentId: string;
+        bindingKey: string;
+        slot: string;
+        target: TelegramTarget & {
+            threadId: number;
+        };
+        leaderEpoch: number | string;
+        retirementRequestedAtMs: number;
+    }) => TelegramWorkspaceRetirementFenceAcquireResult;
+    acquireThreadCleanupFence: (input: {
+        operationId: string;
+        cleanupWorkSetId: string;
+        bindingKey: string;
+        slot: string;
+        target: TelegramTarget & {
+            threadId: number;
+        };
+        leaderEpoch: number | string;
+        cleanupRequestedAtMs: number;
+    }) => TelegramWorkspaceRetirementFenceAcquireResult;
+    adoptRetirementFence: (expected: TelegramWorkspaceRetirementFence, replacement: {
+        owner: TelegramWorkspaceAdmissionOwner;
+        leaderEpoch: number | string;
+    }) => TelegramWorkspaceRetirementFence;
+    adoptThreadCleanupFence: TelegramWorkspaceAdmissionLedger["adoptRetirementFence"];
+    issueDeletionPermit: (expected: TelegramWorkspaceRetirementFence) => TelegramWorkspaceDeletionPermitResult;
+    issueThreadCleanupDeletionPermit: TelegramWorkspaceAdmissionLedger["issueDeletionPermit"];
+    confirmRetirementAbsence: (expected: TelegramWorkspaceRetirementFence) => TelegramWorkspaceRetirementFence;
+    confirmThreadCleanupAbsence: TelegramWorkspaceAdmissionLedger["confirmRetirementAbsence"];
+    releaseUnissuedRetirementFence: (expected: TelegramWorkspaceRetirementFence) => boolean;
+    releaseUnissuedThreadCleanupFence: TelegramWorkspaceAdmissionLedger["releaseUnissuedRetirementFence"];
+    completeRetirementFence: (expected: TelegramWorkspaceRetirementFence) => boolean;
+    completeThreadCleanupFence: TelegramWorkspaceAdmissionLedger["completeRetirementFence"];
+}
+export declare function resolveTelegramWorkspaceDestructiveFenceKind(fence: {
+    destructiveKind?: TelegramWorkspaceDestructiveFenceKind;
+}): TelegramWorkspaceDestructiveFenceKind;
+export declare function createTelegramWorkspaceAdmissionOperationId(): string;
+export declare function createTelegramWorkspaceAdmissionProfileKey(input: {
+    profileName?: string;
+    botToken: string;
+}): string;
+export interface TelegramWorkspaceAdmissionRuntimeBinding {
+    resolve: () => TelegramWorkspaceAdmissionLedger | undefined;
+}
+export declare function createTelegramWorkspaceAdmissionRuntimeBinding(input: {
+    getProfileName: () => string | undefined;
+    getBotToken: () => string | undefined;
+    getPath: (profileName?: string) => string;
+    owner: TelegramWorkspaceAdmissionOwner;
+    getNowMs?: () => number;
+    getProcessLiveness?: (owner: TelegramWorkspaceAdmissionOwner) => TelegramProcessLiveness;
+}): TelegramWorkspaceAdmissionRuntimeBinding;
+export declare function runWithTelegramWorkspaceAdmissions<T>(input: {
+    ledger: Pick<TelegramWorkspaceAdmissionLedger, "acquireAdmission" | "releaseAdmission">;
+    operationId: string;
+    operationKind: string;
+    scopes: readonly TelegramWorkspaceAdmissionScope[];
+    operation: () => T;
+}): T;
+export declare function createTelegramWorkspaceJournalWriterAdmission(input: {
+    ledger: Pick<TelegramWorkspaceAdmissionLedger, "acquireAdmission" | "acquireJournalWriterAdmission" | "releaseAdmission">;
+    protocolAuthority?: Omit<Parameters<TelegramWorkspaceAdmissionLedger["acquireJournalWriterAdmission"]>[0], "operationId">;
+    createOperationId?: () => string;
+    onReleaseError?: (error: unknown) => void;
+}): <T>(operation: () => T) => T;
+export declare function runWithTelegramWorkspaceAdmissionsAsync<T>(input: {
+    ledger: Pick<TelegramWorkspaceAdmissionLedger, "acquireAdmission" | "releaseAdmission">;
+    operationId: string;
+    operationKind: string;
+    scopes: readonly TelegramWorkspaceAdmissionScope[];
+    operation: () => Promise<T>;
+    onReleaseError?: (error: unknown) => void;
+}): Promise<T>;
+export declare function createTelegramWorkspaceAdmissionLedger(options: TelegramWorkspaceAdmissionLedgerOptions): TelegramWorkspaceAdmissionLedger;
+export {};