@llblab/pi-telegram 0.50.1 → 0.51.1

package/dist/lib/bus-follower.js

@@ -9,6 +9,7 @@ import { basename } from "node:path";
 import * as Sync from "./sync.js";
 import * as Threads from "./threads.js";
 import { parseTelegramUpdateJournalQueueOwner } from "./journal.js";
+import { TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS, } from "./locks.js";
 import { isTelegramApiMethodRetrySafe, TelegramApiCommitUnknownError, TelegramApiStaleTargetError, } from "./telegram-api.js";
 import { createTelegramBusFollowerDeliveryIdentity, createTelegramBusFollowerTargetController, createTelegramBusForeignOwnedUpdateForwarder, createTelegramBusLocalServer, createTelegramBusRequestIdFactory, createUnauthorizedBusAck, getTelegramBusProtocolCompatibility, getTelegramBusSocketPath, hasTelegramBusCapability, isTelegramBusEnvelopeAuthorized, resolveTelegramBusSocketPath, sendTelegramBusLocalEnvelope, TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME, TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE, TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT, } from "./bus.js";
 import { getTelegramBusTransportRetryPolicy, TELEGRAM_BUS_REGISTRATION_RETRY, } from "./bus-transport.js";
@@ -17,6 +18,7 @@ export const TELEGRAM_BUS_FOLLOWER_PROMOTION_GRACE_MS = 2_500;
 export const TELEGRAM_FOLLOWER_SESSION_HANDOFF_TTL_MS = 30_000;
 export const TELEGRAM_BUS_FOLLOWER_CLIENT_TIMEOUT_MS = 30_000;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_WAIT_MS = 30_000;
+export const TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS = TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_ATTEMPTS = TELEGRAM_BUS_REGISTRATION_RETRY.attempts;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_DELAY_MS = TELEGRAM_BUS_REGISTRATION_RETRY.delayMs;
 const TELEGRAM_FOLLOWER_SESSION_HANDOFF_KEY = "__piTelegramFollowerSessionHandoff";
@@ -139,6 +141,23 @@ export function createTelegramBusFollowerPromotionHandler(input) {
     });
 }
 export function createTelegramBusFollowerRuntimeAssembly(ports) {
+    // Binding startup needs registration identity before it can grant inbound authority.
+    let readyContext;
+    const isReadyContext = (ctx) => Boolean(readyContext &&
+        (ctx === undefined || readyContext.ctx === ctx) &&
+        ports.registrationState.getGeneration() === readyContext.generation &&
+        ports.registration.getSessionGeneration?.() === readyContext.sessionGeneration &&
+        ports.registration.isContextActive?.(readyContext.ctx) !== false);
+    const prepareContext = async (ctx) => {
+        const generation = ports.registrationState.getGeneration();
+        const sessionGeneration = ports.registration.getSessionGeneration?.();
+        readyContext = undefined;
+        await ports.registration.onRegistered?.(ctx);
+        if (generation && ports.registrationState.getGeneration() === generation &&
+            ports.registration.getSessionGeneration?.() === sessionGeneration &&
+            ports.registration.isContextActive?.(ctx) !== false)
+            readyContext = { generation, ctx, sessionGeneration };
+    };
     const sharedRuntimeDeps = {
         instanceId: ports.instanceId,
         registrationState: ports.registrationState,
@@ -148,7 +167,9 @@ export function createTelegramBusFollowerRuntimeAssembly(ports) {
         ...ports.receiver,
         instanceId: ports.instanceId,
         recordRuntimeEvent: ports.recordRuntimeEvent,
-        getRegistrationGeneration: ports.registrationState.getGeneration,
+        getRegistrationGeneration() {
+            return isReadyContext() ? readyContext?.generation : undefined;
+        },
         handleReplaceTarget: createTelegramBusFollowerTargetReplacementHandler({
             ...ports.targetReplacement,
             ...sharedRuntimeDeps,
@@ -166,8 +187,24 @@ export function createTelegramBusFollowerRuntimeAssembly(ports) {
         ...sharedRuntimeDeps,
         startReceiving: receiver.start,
         stopReceiving: receiver.stop,
+        onRegistered: prepareContext,
         onHeartbeatFailure: recovery,
     });
+    const baseRegistration = registration;
+    registration = {
+        ...baseRegistration,
+        async setContext(ctx) {
+            const sessionGeneration = ports.registration.getSessionGeneration?.();
+            if (ports.registration.isContextActive?.(ctx) === false)
+                return;
+            await baseRegistration.setContext(ctx);
+            if (ports.registration.getSessionGeneration?.() !== sessionGeneration ||
+                ports.registration.isContextActive?.(ctx) === false)
+                return;
+            if (!isReadyContext(ctx))
+                await prepareContext(ctx);
+        },
+    };
     return { receiver, registration };
 }
 export function createTelegramBusFollowerTargetReplacementHandler(deps) {
@@ -575,7 +612,15 @@ export function createTelegramBusFollowerSessionRefreshHook(deps) {
             return;
         if (deps.isSessionActive && !deps.isSessionActive(ctx))
             return;
-        deps.registrationRuntime.setContext(ctx);
+        try {
+            await deps.registrationRuntime.setContext(ctx);
+        }
+        catch (error) {
+            deps.recordRuntimeEvent("bus", error, { phase: "follower-session-refresh" });
+            return;
+        }
+        if (deps.isSessionActive && !deps.isSessionActive(ctx))
+            return;
         deps.updateStatus(ctx);
         deps.recordRuntimeEvent("bus", "Telegram follower session context refreshed", { phase: "follower-session-refresh" });
     };
@@ -877,6 +922,9 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
     const getNowMs = deps.getNowMs ?? Date.now;
     const getPid = deps.getPid ?? (() => process.pid);
     const heartbeatMs = deps.heartbeatMs ?? 1000;
+    const heartbeatTimeoutMs = deps.heartbeatTimeoutMs ??
+        deps.timeoutMs ??
+        TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS;
     const registrationTimeoutMs = deps.registrationTimeoutMs ?? deps.timeoutMs ?? 30000;
     const registrationRetryAttempts = deps.registrationRetryAttempts ??
         TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_ATTEMPTS;
@@ -888,6 +936,7 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
     let activeLeaderSocketPath;
     let activeAuthSecret;
     let activeRegistrationGeneration;
+    let registrationAttempt;
     let activeContext;
     let lastKnownTarget;
     let lastKnownSlot;
@@ -899,6 +948,7 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
         heartbeatInterval = undefined;
     };
     const stop = () => {
+        registrationAttempt = undefined;
         stopHeartbeat();
         activeAuthSecret = undefined;
         activeRegistrationGeneration = undefined;
@@ -934,7 +984,7 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
         try {
             const response = await sendTelegramBusLocalEnvelope({
                 socketPath: leaderSocketPath,
-                timeoutMs: deps.timeoutMs,
+                timeoutMs: heartbeatTimeoutMs,
                 retry: getTelegramBusTransportRetryPolicy({
                     endpoint: leaderSocketPath,
                     operation: "operation",
@@ -1027,6 +1077,26 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
     };
     return {
         registerWithLeader: async (ctx, leader, options) => {
+            if (deps.isContextActive?.(ctx) === false)
+                return false;
+            const sessionGeneration = deps.getSessionGeneration?.();
+            const attempt = { ctx, sessionGeneration };
+            registrationAttempt = attempt;
+            const isCurrentRequest = () => registrationAttempt === attempt &&
+                deps.getSessionGeneration?.() === sessionGeneration && deps.isContextActive?.(ctx) !== false;
+            const abandonOwnedRequest = async () => {
+                if (registrationAttempt !== attempt)
+                    return;
+                registrationAttempt = undefined;
+                stopHeartbeat();
+                activeLeaderSocketPath = undefined;
+                activeAuthSecret = undefined;
+                activeRegistrationGeneration = undefined;
+                activeContext = undefined;
+                deps.registrationState?.setRegistered(false);
+                deps.setActiveAuthSecret?.(undefined);
+                await deps.stopReceiving?.();
+            };
             const pendingHandoff = options
                 ? undefined
                 : getTelegramFollowerSessionHandoff();
@@ -1041,6 +1111,10 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
                 deps.getLeaderSocketPath?.() ??
                 getTelegramBusSocketPath();
             await deps.startReceiving?.();
+            if (!isCurrentRequest()) {
+                await abandonOwnedRequest();
+                return false;
+            }
             activeAuthSecret = deps.getLeaderAuthSecret
                 ? deps.getLeaderAuthSecret(leader)
                 : leader?.busSecret;
@@ -1070,7 +1144,7 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
                     sessionId: deps.getSessionId?.(ctx),
                     pid: getPid(),
                     processBirthId: deps.getProcessBirthId?.(),
-                    sessionGeneration: deps.getSessionGeneration?.(),
+                    sessionGeneration,
                     target: registrationOptions?.target ??
                         deps.registrationState?.getTarget() ??
                         lastKnownTarget,
@@ -1103,6 +1177,10 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
                 });
             }
             catch (error) {
+                if (!isCurrentRequest()) {
+                    await abandonOwnedRequest();
+                    return false;
+                }
                 stopHeartbeat();
                 activeLeaderSocketPath = undefined;
                 activeAuthSecret = undefined;
@@ -1111,12 +1189,8 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
                 await deps.stopReceiving?.();
                 throw error;
             }
-            if (deps.isContextActive && !deps.isContextActive(ctx)) {
-                stopHeartbeat();
-                activeLeaderSocketPath = undefined;
-                activeAuthSecret = undefined;
-                deps.setActiveAuthSecret?.(undefined);
-                await deps.stopReceiving?.();
+            if (!isCurrentRequest()) {
+                await abandonOwnedRequest();
                 return false;
             }
             const compatibility = getTelegramBusProtocolCompatibility({
@@ -1164,6 +1238,10 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
                     await deps.onRegistered?.(ctx);
                 }
                 catch (error) {
+                    if (!isCurrentRequest()) {
+                        await abandonOwnedRequest();
+                        return false;
+                    }
                     stopHeartbeat();
                     activeLeaderSocketPath = undefined;
                     activeAuthSecret = undefined;
@@ -1173,7 +1251,15 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
                     await deps.stopReceiving?.();
                     throw error;
                 }
+                if (!isCurrentRequest()) {
+                    await abandonOwnedRequest();
+                    return false;
+                }
                 await requestHeartbeat();
+                if (!isCurrentRequest()) {
+                    await abandonOwnedRequest();
+                    return false;
+                }
                 startHeartbeat(leaderSocketPath);
                 if (pendingHandoffOptions &&
                     getTelegramFollowerSessionHandoff()?.instanceId ===
@@ -1191,6 +1277,9 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
             return false;
         },
         setContext(ctx) {
+            if (registrationAttempt && (registrationAttempt.ctx !== ctx ||
+                registrationAttempt.sessionGeneration !== deps.getSessionGeneration?.()))
+                registrationAttempt = undefined;
             activeContext = ctx;
         },
         async setThreadDisplayMode(mode) {

package/dist/lib/bus-leader.d.ts

@@ -12,7 +12,7 @@ import type { TelegramTarget } from "./target.ts";
 import * as Threads from "./threads.ts";
 import { type TelegramBusEnvelope, type TelegramBusFollowerRegistry, type TelegramBusFollowerView, type TelegramBusInstanceRegistration, type TelegramBusProtocolIdentity, type TelegramBusSocketPathSource } from "./bus.ts";
 import type { TelegramQueueHandoffPayload } from "./queue.ts";
-import { type TelegramWorkspaceOperationRunner } from "./workspace-retirement.ts";
+import { type TelegramWorkspaceCapacityRunner, type TelegramWorkspaceSlotRotationPorts, type TelegramWorkspaceOperationRunner } from "./workspace-retirement.ts";
 import { type TelegramWorkspaceAdmissionLedger } from "./workspace-admission.ts";
 export declare const TELEGRAM_BUS_FOLLOWER_STALE_AFTER_MS = 15000;
 export type TelegramBusWorkspaceAdmissionRunner = TelegramWorkspaceOperationRunner;
@@ -90,7 +90,7 @@ export interface TelegramBusFollowerTargetProvisionerDeps {
     recordRuntimeEvent: (category: string, error: unknown, details?: Record<string, unknown>) => void;
 }
 export interface TelegramBusFollowerDisconnectHandlerDeps {
-    topicTargetStore: Pick<Threads.TelegramTopicTargetStore, "list" | "markStaleByTarget" | "markWorkspaceBindingInactiveByTarget" | "persist" | "upsertPendingCleanup" | "removePendingCleanup">;
+    topicTargetStore: Pick<Threads.TelegramTopicTargetStore, "list" | "markStaleByTarget" | "persist" | "upsertPendingCleanup" | "removePendingCleanup">;
     callApi: <TResponse>(method: string, body: Record<string, unknown>) => Promise<TResponse>;
     getCurrentLeaderEpoch?: () => number | string | undefined;
     getSyncState: () => Sync.TelegramSyncState;
@@ -108,7 +108,7 @@ export interface TelegramBusLeaderRuntimeAssemblyDeps<TContext> {
     getThreadDisplayMode?: () => TelegramThreadDisplayMode;
     persistThreadDisplayMode?: (mode: TelegramThreadDisplayMode, isCurrent: () => boolean) => Promise<void>;
     onThreadDisplayChanged?: () => void;
-    runtime: Omit<TelegramBusLeaderRuntimeDeps<TContext>, "callApi" | "onFollowerDisconnected" | "onFollowerConfirmedDead" | "provisionFollowerTarget" | "provisionLeaderTarget" | "recordRuntimeEvent">;
+    runtime: Omit<TelegramBusLeaderRuntimeDeps<TContext>, "callApi" | "onFollowerDisconnected" | "onFollowerConfirmedDead" | "onFollowerConfirmedDeadPreserved" | "getTelegramProfile" | "provisionFollowerTarget" | "provisionLeaderTarget" | "recordRuntimeEvent">;
     getAllowedUserId: () => number | undefined;
     instanceId: string;
     getCwd?: (ctx: TContext) => string | undefined;
@@ -133,6 +133,7 @@ export interface TelegramBusLeaderRuntimeAssemblyDeps<TContext> {
     captureWorkspaceExternalProtection?: (binding: Threads.TelegramWorkspaceThreadBinding) => Threads.TelegramWorkspaceExternalProtectionEvidence;
     getWorkspaceAdmission?: () => Pick<TelegramWorkspaceAdmissionLedger, "acquireAdmission" | "releaseAdmission"> | undefined;
     runWorkspaceOperation?: TelegramBusWorkspaceAdmissionRunner;
+    workspaceRotation?: TelegramWorkspaceSlotRotationPorts;
 }
 export declare function createTelegramBusLeaderRuntimeAssembly<TContext>(deps: TelegramBusLeaderRuntimeAssemblyDeps<TContext>): TelegramBusLeaderRuntime<TContext> & {
     renameLeaderThreadAdmitted: (threadName: string, expectedTarget?: Threads.TelegramTopicTargetRecord["target"]) => Promise<Threads.TelegramTopicTargetRecord>;
@@ -192,8 +193,10 @@ export interface TelegramBusLeaderRuntimeDeps<TContext> {
     applyThreadDisplayMode?: (mode: TelegramThreadDisplayMode, isCurrent: () => boolean) => Promise<void>;
     getThreadDisplayMode?: () => TelegramThreadDisplayMode;
     getCurrentLeaderEpoch?: () => number | string | undefined;
+    getTelegramProfile?: () => string | undefined;
     provisionLeaderTarget?: (ctx: TContext) => Promise<void> | void;
     runWorkspaceAdmission?: TelegramBusWorkspaceAdmissionRunner;
+    runWithWorkspaceCapacity?: TelegramWorkspaceCapacityRunner;
     getNowMs?: () => number;
     timeoutMs?: number;
     followerPruneIntervalMs?: number;
@@ -202,6 +205,8 @@ export interface TelegramBusLeaderRuntimeDeps<TContext> {
     shouldCleanupConfirmedDeadFollower?: () => Promise<boolean> | boolean;
     onFollowerDisconnected?: (follower: TelegramBusFollowerView) => Promise<void> | void;
     onFollowerConfirmedDead?: (follower: TelegramBusFollowerView) => Promise<void> | void;
+    /** True settles this observation; false needs fresh proof before another attempt. */
+    onFollowerConfirmedDeadPreserved?: (follower: TelegramBusFollowerView, isDetached: () => boolean, operationId: string) => Promise<boolean> | boolean;
     recordRuntimeEvent?: (category: string, error: unknown, details?: Record<string, unknown>) => void;
 }
 export declare function createTelegramBusInstanceLifecycleAnnouncement(input: {
@@ -275,6 +280,7 @@ export declare function createTelegramBusLeaderEnvelopeHandler(deps: {
     getCurrentLeaderEpoch?: () => number | string | undefined;
     runFollowerMutation?: TelegramBusFollowerMutationRunner;
     runWorkspaceAdmission?: TelegramBusWorkspaceAdmissionRunner;
+    runWithWorkspaceCapacity?: TelegramWorkspaceCapacityRunner;
 }): (envelope: TelegramBusEnvelope) => Promise<TelegramBusEnvelope> | TelegramBusEnvelope;
 export interface TelegramBusLeaderActivationSchedulerDeps<TContext> {
     isBusEnabled: () => boolean;