@pasko70/pibo 3.4.4 → 3.5.1

package/dist/core/session-router.js

@@ -1,3 +1,6 @@
+import { previouslyClearedMessages } from "./events.js";
+import { createProviderCapacityExtension } from "./provider-capacity.js";
+import { RuntimeCapacity } from "./runtime-capacity.js";
 import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { InitialSessionContext, } from "./profiles.js";
@@ -172,6 +175,39 @@ function formatRunReminderMessage(notification) {
 function isRunReminderServiceMessage(event) {
     return event.source === "service" && event.text.startsWith("<pibo_run_notification>");
 }
+const RUNTIME_QUEUE_CAPACITY_DIMENSIONS = new Set([
+    "message_bytes",
+    "queue_count",
+    "queue_bytes",
+    "oldest_wait_age",
+]);
+function runReminderAdmissionDiagnostic(error) {
+    if (!error || typeof error !== "object" || !("code" in error) || error.code !== "runtime_capacity_unavailable") {
+        return {
+            code: "run_reminder_delivery_unavailable",
+            warning: "Run reminder deferred: internal delivery is temporarily unavailable; pending run state is retained.",
+        };
+    }
+    const candidate = error;
+    const dimension = typeof candidate.dimension === "string"
+        && RUNTIME_QUEUE_CAPACITY_DIMENSIONS.has(candidate.dimension)
+        ? candidate.dimension
+        : undefined;
+    const current = candidate.current
+        && ["messageBytes", "queueCount", "queueBytes", "oldestWaitMs"].every((key) => (typeof candidate.current?.[key] === "number" && Number.isFinite(candidate.current[key]) && candidate.current[key] >= 0))
+        ? candidate.current
+        : undefined;
+    const limit = typeof candidate.limit === "number" && Number.isFinite(candidate.limit) && candidate.limit >= 0
+        ? candidate.limit
+        : undefined;
+    return {
+        code: "runtime_capacity_unavailable",
+        warning: `Run reminder deferred: runtime queue${dimension ? ` ${dimension}` : ""} capacity is unavailable; pending run state is retained.`,
+        ...(dimension ? { dimension } : {}),
+        ...(current ? { current } : {}),
+        ...(limit !== undefined ? { limit } : {}),
+    };
+}
 function isRunReminderContextPressureError(event) {
     return event.errorDetails?.category === "context_overflow"
         || event.errorDetails?.code === "context_length_exceeded"
@@ -333,6 +369,10 @@ function providerEventTelemetryModeFromEnv(env = process.env) {
 export class PiboSessionRouter {
     options;
     sessions = new Map();
+    capacity;
+    creatingRuntimes = 0;
+    initializationTimings = [];
+    pendingStartAborts = new Map();
     pendingSessions = new Map();
     listeners = new Set();
     outputRenderSequencer;
@@ -358,6 +398,7 @@ export class PiboSessionRouter {
     deferredRunReminders = new Map();
     runReminderRecoveries = new Map();
     runReminderGenerations = new Map();
+    runReminderAdmissionWarnings = new Map();
     runCancellationHandlers = new Map();
     activeRunExecutions = new Set();
     quiescingSessions = new Set();
@@ -378,6 +419,7 @@ export class PiboSessionRouter {
     closing = false;
     constructor(options = {}) {
         this.options = options;
+        this.capacity = new RuntimeCapacity(options.runtimeCapacity);
         this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
         // Historical custom registries supplied only actions/profiles while runtime creation was implicit.
         // Preserve that composition contract during the adapter migration without branching on adapter ids.
@@ -450,6 +492,16 @@ export class PiboSessionRouter {
     async emit(event) {
         if (this.closing)
             throw new Error("Pibo session router is disposed.");
+        if (event.type === "execution" && !this.sessions.has(event.piboSessionId) && (event.action === "abort" || event.action === "clear_queue")) {
+            this.resolvePiboSession(event.piboSessionId);
+            if (event.action === "abort") {
+                this.invalidateRunReminders([event.piboSessionId]);
+                this.pendingStartAborts.get(event.piboSessionId)?.abort(Object.assign(new Error("Runtime start aborted before message dispatch."), { code: "runtime_start_cancelled" }));
+            }
+            const output = { type: "execution_result", piboSessionId: event.piboSessionId, eventId: event.id, action: event.action, result: event.action === "abort" ? { aborted: true } : { cleared: previouslyClearedMessages(event) } };
+            this.emitOutput(output);
+            return output;
+        }
         let messageSignalAccepted = false;
         const acceptMessageSignal = () => {
             if (event.type !== "message" || !event.id || messageSignalAccepted)
@@ -1020,6 +1072,13 @@ export class PiboSessionRouter {
     listRuns(options = {}) {
         return this.runRegistry.listAll(options);
     }
+    getRunJobReliabilityStatus() {
+        return this.reliabilityStore?.getRunJobReliabilityStatus() ?? {
+            status: "ok",
+            expiredOrphanRunJobs: 0,
+            orphanRunDeadLetters: 0,
+        };
+    }
     getSignalRegistry() {
         return this.signalRegistry;
     }
@@ -1126,6 +1185,7 @@ export class PiboSessionRouter {
         if (this.disposePromise)
             return this.disposePromise;
         this.closing = true;
+        this.capacity.close();
         this.disposePromise = this.disposeAllUnsafe();
         return this.disposePromise;
     }
@@ -1245,16 +1305,65 @@ export class PiboSessionRouter {
         const pending = this.pendingSessions.get(piboSessionId);
         if (pending)
             return pending;
-        const created = this.createRoutedSession(piboSessionId);
+        const startAbort = new AbortController();
+        this.pendingStartAborts.set(piboSessionId, startAbort);
+        const created = this.createRoutedSessionWithinCapacity(piboSessionId, startAbort.signal);
         this.pendingSessions.set(piboSessionId, created);
         try {
             return await created;
         }
         finally {
             this.pendingSessions.delete(piboSessionId);
+            if (this.pendingStartAborts.get(piboSessionId) === startAbort)
+                this.pendingStartAborts.delete(piboSessionId);
+        }
+    }
+    getRuntimeCapacityStatus() { return { ...this.capacity.snapshot(), telemetry: this.telemetryWriter?.status(), activeRuntimes: this.sessions.size, initializingRuntimes: this.creatingRuntimes, recentInitializations: this.initializationTimings.map(item => ({ ...item, phases: { ...item.phases } })) }; }
+    async createRoutedSessionWithinCapacity(piboSessionId, signal) {
+        const stored = this.resolvePiboSession(piboSessionId);
+        const room = typeof stored.metadata?.chatRoomId === "string" ? stored.metadata.chatRoomId : piboSessionId;
+        const queuedAt = performance.now();
+        const lease = await this.capacity.starts.acquire(room, signal);
+        const startedAt = performance.now();
+        const phases = {};
+        let outcome = "failed";
+        try {
+            signal.throwIfAborted();
+            if (this.closing || this.quiescingSessions.has(piboSessionId))
+                throw new Error("Runtime start cancelled during session shutdown.");
+            if (this.sessions.size + this.creatingRuntimes >= this.capacity.maxRuntimes) {
+                const idle = [...this.sessions].find(([id, session]) => { if (this.pendingSessions.has(id))
+                    return false; const status = session.getStatus(); return !status.disposed && !status.processing && !status.streaming && status.queuedMessages === 0; });
+                if (idle)
+                    await this.evictIdleSession(idle[0], idle[1]);
+            }
+            if (this.sessions.size + this.creatingRuntimes >= this.capacity.maxRuntimes)
+                throw Object.assign(new Error("Active runtime capacity reached."), { code: "runtime_capacity_unavailable" });
+            this.creatingRuntimes++;
+            try {
+                const session = await this.createRoutedSession(piboSessionId, phases);
+                if (signal.aborted) {
+                    if (this.sessions.get(piboSessionId) === session)
+                        this.sessions.delete(piboSessionId);
+                    await this.disposeRoutedSession(piboSessionId, session, "cold start aborted");
+                    throw signal.reason;
+                }
+                outcome = "ready";
+                return session;
+            }
+            finally {
+                this.creatingRuntimes--;
+            }
+        }
+        finally {
+            lease.release();
+            this.initializationTimings.push({ sessionId: piboSessionId, waitMs: startedAt - queuedAt, totalMs: performance.now() - startedAt, phases, outcome });
+            if (this.initializationTimings.length > 32)
+                this.initializationTimings.shift();
         }
     }
-    async createRoutedSession(piboSessionId) {
+    async createRoutedSession(piboSessionId, phases = {}) {
+        let phaseStarted = performance.now();
         const piboSession = this.resolvePiboSession(piboSessionId);
         let session;
         this.signalRegistry.project({ type: "session_created", session: piboSession });
@@ -1313,6 +1422,8 @@ export class PiboSessionRouter {
         if (invalidProfile) {
             throw new Error(`Runtime profile validation failed: ${invalidProfile.message}`);
         }
+        phases.bindingAndProfileMs = performance.now() - phaseStarted;
+        phaseStarted = performance.now();
         let historyHandoff;
         if (persistedHistoryHandoff?.mode === "import") {
             if (!runtimeAdapter.descriptor.capabilities.historyImport) {
@@ -1336,6 +1447,8 @@ export class PiboSessionRouter {
         else if (persistedHistoryHandoff?.mode === "fresh") {
             historyHandoff = { mode: "fresh" };
         }
+        phases.portableHistoryMs = performance.now() - phaseStarted;
+        phaseStarted = performance.now();
         const initialFastMode = resolvePiboSessionInitialFastMode(piboSession) ?? selectRequestedFastMode(sessionProfile, modelDefaults) ?? false;
         const agentsController = this.createAgentsController(piboSession.id);
         const runToolController = this.createRunToolController(piboSession.id);
@@ -1380,6 +1493,8 @@ export class PiboSessionRouter {
                 this.portableToolSessions.delete(piboSession.id);
             throw error;
         }
+        phases.resourcesAndToolsMs = performance.now() - phaseStarted;
+        phaseStarted = performance.now();
         const bindingSync = { expectedRevision: binding.revision };
         const runtimeBindingPersistence = createAgentRuntimeBindingPersistence(this.sessionStore, {
             piboSessionId: piboSession.id,
@@ -1423,6 +1538,7 @@ export class PiboSessionRouter {
                         thinkingLevel: initialThinkingLevel ?? this.options.thinkingLevel,
                         retryDefaults: resolvePiboSessionRetryDefaults(piboSession.kind, this.options.retryDefaults),
                         extensionFactories: [
+                            createProviderCapacityExtension(this.capacity, piboRoomIdFromMetadata(piboSession.metadata) ?? piboSession.id, Boolean(piboSession.parentId)),
                             ...(telemetryExtension ? [telemetryExtension] : []),
                             ...(this.options.extensionFactories ?? []),
                         ],
@@ -1492,6 +1608,7 @@ export class PiboSessionRouter {
                 this.runtimeResourceSessions.delete(piboSession.id);
             throw error;
         }
+        phases.adapterOpenAndBindingMs = performance.now() - phaseStarted;
         const resourceInspection = resources.getInspection();
         const statusResources = {
             enabledSkills: [...new Set(resourceInspection.skills.map((skill) => skill.name))],
@@ -1533,6 +1650,7 @@ export class PiboSessionRouter {
                 this.handleInterruptedRunReminders(messages);
             },
             messagePreflight: this.options.messagePreflight,
+            acquireProviderCapacity: runtimeAdapter.descriptor.id === "pi" ? undefined : (provider, signal) => this.capacity.acquireProvider(provider, typeof piboSession.metadata?.chatRoomId === "string" ? piboSession.metadata.chatRoomId : piboSession.id, signal, Boolean(piboSession.parentId)),
             modelFallbacks,
             getRuntimeAuthStatus: () => runtimeRegistry.getAgentRuntimeAuthStatus(binding.runtimeInstanceId),
             startRuntimeAuth: async (input) => {
@@ -1553,6 +1671,7 @@ export class PiboSessionRouter {
             },
             statusResources,
             getToolMetricTokenCalculation: () => loadPiboUserSettings().toolMetrics.tokenCalculation,
+            now: this.options.runtimeQueueNow,
         });
         this.sessions.set(piboSession.id, session);
         return session;
@@ -2584,6 +2703,7 @@ export class PiboSessionRouter {
             this.runRegistry.suppressNotification(delivery.piboSessionId, run.runId);
         this.clearRunReminderRecovery(delivery);
         this.deferredRunReminders.delete(delivery.piboSessionId);
+        this.clearRunReminderAdmissionWarning(delivery.piboSessionId, delivery.generation);
         this.sessions.get(delivery.piboSessionId)?.removeQueuedMessages(isRunReminderServiceMessage);
         this.scheduleRunReminder(delivery.piboSessionId, false, delivery.generation);
     }
@@ -2673,6 +2793,7 @@ export class PiboSessionRouter {
             this.scheduledRunReminders.delete(piboSessionId);
             this.deferredRunReminders.delete(piboSessionId);
             this.runReminderRecoveries.delete(piboSessionId);
+            this.clearRunReminderAdmissionWarning(piboSessionId);
             for (const [eventId, delivery] of this.runReminderDeliveries) {
                 if (delivery.piboSessionId === piboSessionId)
                     this.runReminderDeliveries.delete(eventId);
@@ -2710,8 +2831,18 @@ export class PiboSessionRouter {
             return;
         if (deferredGeneration !== undefined)
             this.deferredRunReminders.delete(piboSessionId);
-        if (!this.runRegistry.hasPendingNotification(piboSessionId, { includeAlreadyNotified }))
+        if (!this.runRegistry.hasPendingNotification(piboSessionId, { includeAlreadyNotified })) {
+            this.clearRunReminderAdmissionWarning(piboSessionId, expectedGeneration);
             return;
+        }
+        if (includeAlreadyNotified) {
+            const status = this.sessions.get(piboSessionId)?.getStatus?.();
+            const effectiveEventIds = new Set([status?.activeEventId, ...(status?.queuedEventIds ?? [])].filter((id) => Boolean(id)));
+            if ([...this.runReminderDeliveries.entries()].some(([eventId, delivery]) => (effectiveEventIds.has(eventId)
+                && delivery.piboSessionId === piboSessionId
+                && delivery.generation === expectedGeneration)))
+                return;
+        }
         const previous = this.scheduledRunReminders.get(piboSessionId);
         if (previous?.generation === expectedGeneration) {
             this.scheduledRunReminders.set(piboSessionId, {
@@ -2727,8 +2858,33 @@ export class PiboSessionRouter {
     }
     refreshQueuedRunReminders(piboSessionId) {
         const removed = this.sessions.get(piboSessionId)?.removeQueuedMessages(isRunReminderServiceMessage) ?? 0;
-        if (removed > 0)
+        if (removed > 0) {
             this.scheduleRunReminder(piboSessionId, true);
+        }
+        else if (!this.runRegistry.hasPendingNotification(piboSessionId, { includeAlreadyNotified: true })) {
+            this.clearRunReminderAdmissionWarning(piboSessionId);
+        }
+    }
+    clearRunReminderAdmissionWarning(piboSessionId, generation) {
+        if (generation !== undefined && this.runReminderAdmissionWarnings.get(piboSessionId) !== generation)
+            return;
+        this.runReminderAdmissionWarnings.delete(piboSessionId);
+        this.sessions.get(piboSessionId)?.setRunReminderDeferredWarning?.(undefined);
+    }
+    deferRunReminderAdmission(piboSessionId, generation, error) {
+        const diagnostic = runReminderAdmissionDiagnostic(error);
+        this.sessions.get(piboSessionId)?.setRunReminderDeferredWarning?.(diagnostic.warning);
+        if (this.runReminderAdmissionWarnings.get(piboSessionId) === generation)
+            return;
+        this.runReminderAdmissionWarnings.set(piboSessionId, generation);
+        console.warn("[pibo] run reminder deferred", {
+            piboSessionId,
+            generation,
+            code: diagnostic.code,
+            ...(diagnostic.dimension ? { dimension: diagnostic.dimension } : {}),
+            ...(diagnostic.current ? { current: diagnostic.current } : {}),
+            ...(diagnostic.limit !== undefined ? { limit: diagnostic.limit } : {}),
+        });
     }
     async deliverRunReminder(piboSessionId, expectedGeneration) {
         const scheduled = this.scheduledRunReminders.get(piboSessionId);
@@ -2743,9 +2899,21 @@ export class PiboSessionRouter {
             const session = await this.getOrCreateSession(piboSessionId);
             if (this.closing || this.quiescingSessions.has(piboSessionId) || expectedGeneration !== this.runReminderGeneration(piboSessionId))
                 return;
-            notification = this.runRegistry.createNotification(piboSessionId, { includeAlreadyNotified: scheduled.includeAlreadyNotified });
-            if (!notification)
+            // Release the queued snapshot before reserving its replacement. The
+            // interruption callback restores every unconsumed run to pending state.
+            const replaced = session.removeQueuedMessages?.((event) => {
+                if (!isRunReminderServiceMessage(event) || !event.id)
+                    return false;
+                const delivery = this.runReminderDeliveries.get(event.id);
+                return delivery?.piboSessionId === piboSessionId && delivery.generation === expectedGeneration;
+            }) ?? 0;
+            notification = this.runRegistry.createNotification(piboSessionId, {
+                includeAlreadyNotified: scheduled.includeAlreadyNotified || replaced > 0,
+            });
+            if (!notification) {
+                this.clearRunReminderAdmissionWarning(piboSessionId, expectedGeneration);
                 return;
+            }
             eventId = randomUUID();
             this.runReminderDeliveries.set(eventId, { piboSessionId, generation: expectedGeneration, notification });
             session.enqueueMessage({
@@ -2756,6 +2924,7 @@ export class PiboSessionRouter {
                 id: eventId,
                 provenance: runReminderProvenance(notification),
             });
+            this.clearRunReminderAdmissionWarning(piboSessionId, expectedGeneration);
         }
         catch (error) {
             if (eventId)
@@ -2764,13 +2933,9 @@ export class PiboSessionRouter {
                 this.runRegistry.releaseNotification(piboSessionId, notification);
             if (this.closing || this.quiescingSessions.has(piboSessionId) || expectedGeneration !== this.runReminderGeneration(piboSessionId))
                 return;
-            const message = error instanceof Error ? error.message : String(error);
-            this.emitOutput({
-                type: "session_error",
-                piboSessionId,
-                error: message,
-                errorDetails: runtimeSessionErrorDetails(message),
-            });
+            // Reminder delivery is internal recovery work. Preserve it for the next
+            // bounded state transition instead of emitting an unscoped fatal error.
+            this.deferRunReminderAdmission(piboSessionId, expectedGeneration, error);
         }
     }
 }

package/dist/data/async-chat-reads.js

@@ -0,0 +1,38 @@
+import { BoundedWorkerClient } from "./bounded-worker-client.js";
+export const CHAT_READ_METHODS = {
+    timeline: ["listEvents", "listSessionEvents", "listAllSessionEvents", "listMessageTurnTimings", "scanMessageTurnTimings", "listTraceEvents", "isPayloadAttachedToTraceNode", "countEventsByType", "getLatestEventSequence", "getLatestStreamId"],
+    history: ["listProductHistoryEntries", "getProductHistoryCoverage"],
+    navigation: ["unreadCountsPage", "sessionIndexPage"],
+};
+/** Read traffic owns a separate connection and queue from admission and output commits. */
+export class AsyncChatReadQueries {
+    path;
+    payloadRootDir;
+    client;
+    closed = false;
+    restarts = 0;
+    restartAfter = 0;
+    timeline;
+    navigation;
+    history;
+    constructor(path, payloadRootDir) {
+        this.path = path;
+        this.payloadRootDir = payloadRootDir;
+        this.client = this.startWorker();
+        const group = (name) => Object.fromEntries(CHAT_READ_METHODS[name].map(method => [method, (...args) => this.getClient().request({ group: name, method, args }, { priority: "background", fairnessKey: typeof args[0] === "string" ? args[0] : args[0]?.piboSessionId })]));
+        this.timeline = group("timeline");
+        this.history = group("history");
+        this.navigation = group("navigation");
+    }
+    startWorker() {
+        this.restartAfter = Date.now() + 1000;
+        return new BoundedWorkerClient(new URL("./chat-read-worker.js", import.meta.url), { maxPending: 64, reservedControlRequests: 2, reservedControlBytes: 16384, maxPendingBytes: 1024 * 1024, maxMessageBytes: 4 * 1024 * 1024, maxAgeMs: 2000, workerOptions: { workerData: { path: this.path, payloadRootDir: this.payloadRootDir } } });
+    }
+    getClient() { if (!this.closed && this.client.status().closed && this.client.status().exited && Date.now() >= this.restartAfter) {
+        this.restarts++;
+        this.client = this.startWorker();
+    } return this.client; }
+    maintenance(action) { return this.getClient().request({ group: "maintenance", method: action, args: [] }, { priority: "control" }); }
+    status() { return { ...this.client.status(), restarts: this.restarts }; }
+    async close() { this.closed = true; await this.client.close(); }
+}

package/dist/data/async-chat-storage.js

@@ -0,0 +1,96 @@
+import { BoundedWorkerClient, StorageUnavailableError } from "./bounded-worker-client.js";
+/** Admission/output writer; bulk reads must use a separate worker connection. */
+export class AsyncChatStorage {
+    writerClient;
+    reader;
+    workerUrl;
+    workerOptions;
+    closed = false;
+    writerRestarts = 0;
+    readerRestarts = 0;
+    writerRestartAfter = 0;
+    readerRestartAfter = 0;
+    constructor(path, payloadRootDir, options = {}) {
+        if (path === ":memory:")
+            throw new Error("Worker storage requires a file-backed database.");
+        // Admission carries the bounded message plus its event projection; account for both in IPC.
+        this.workerOptions = { maxMessageBytes: 4 * 1024 * 1024, reservedControlRequests: 8, reservedControlBytes: 256 * 1024, admissionWindowMs: 1, ...options, workerOptions: { ...options.workerOptions, workerData: { path, payloadRootDir } } };
+        this.workerUrl = new URL("./chat-storage-worker.js", import.meta.url);
+        this.writerClient = this.startWriter();
+    }
+    /**
+     * A crashed worker, or one that breached its execution deadline, must not disable durable
+     * admission permanently. Replacement waits for the failed worker to exit and is bounded to one
+     * per second, so two writers never own the same SQLite file. Recovery is safe without replay
+     * protection because callers reconcile the same client transaction ID and admission is
+     * idempotent by request key.
+     */
+    get writer() {
+        const status = this.writerClient.status();
+        if (!this.closed && status.closed && status.exited && Date.now() >= this.writerRestartAfter) {
+            this.writerRestarts++;
+            this.writerClient = this.startWriter();
+        }
+        return this.writerClient;
+    }
+    get readerClient() {
+        const status = this.reader?.status();
+        if (!this.reader || (!this.closed && status.closed && status.exited && Date.now() >= this.readerRestartAfter)) {
+            if (this.reader)
+                this.readerRestarts++;
+            this.reader = this.startReader();
+        }
+        return this.reader;
+    }
+    startWriter() {
+        this.writerRestartAfter = Date.now() + 1000;
+        return new BoundedWorkerClient(this.workerUrl, this.workerOptions);
+    }
+    startReader() {
+        this.readerRestartAfter = Date.now() + 1000;
+        return new BoundedWorkerClient(this.workerUrl, this.workerOptions);
+    }
+    resolveRoom(roomId, required = false) {
+        return this.writer.request({ type: "resolveRoom", roomId, required });
+    }
+    admit(input, session, text, durableCommand) {
+        if (durableCommand && Buffer.byteLength(text) > 1024 * 1024)
+            return Promise.reject(Object.assign(new Error("Message exceeds the durable command byte limit."), { code: "command_too_large" }));
+        return this.writer.request({ type: "admit", input, session, text, durableCommand }, { fairnessKey: input.roomId, priority: durableCommand?.delivery === "steer" ? "control" : "admission" });
+    }
+    append(input) {
+        return this.writer.request({ type: "append", input });
+    }
+    find(roomId, actorId, clientTxnId) {
+        if (this.closed)
+            return Promise.reject(new StorageUnavailableError("storage_closed", "Storage worker is closed."));
+        return this.readerClient.request({ type: "find", roomId, actorId, clientTxnId }, { priority: "admission" });
+    }
+    ingestUser(input) {
+        return this.writer.request({ type: "ingestUser", input });
+    }
+    async ingestOutput(input) {
+        const result = await this.writer.request({ type: "ingestOutput", input }, { priority: "output", fairnessKey: input.roomId });
+        if (input.event.type === "compaction_end" && result.enrichment?.compactionStats) {
+            input.event.compactionStats = result.enrichment.compactionStats;
+        }
+        return result;
+    }
+    cancelPendingCommands(sessionId) { return this.writer.request({ type: "cancelPendingCommands", sessionId }, { priority: "control" }); }
+    commandReceiptPage(sessionId) { return this.writer.request({ type: "commandReceiptPage", sessionId }, { priority: "control" }); }
+    commandReceipts(sessionId) { return this.writer.request({ type: "commandReceipts", sessionId }, { priority: "control" }); }
+    commandReceipt(id) { return this.writer.request({ type: "commandReceipt", id }, { priority: "control" }); }
+    claimCommand(owner, leaseMs) { return this.writer.request({ type: "claimCommand", owner, leaseMs }, { priority: "background" }); }
+    transitionCommand(id, owner, token, state, error) { return this.writer.request({ type: "transitionCommand", id, owner, token, state, error }, { priority: "control" }); }
+    heartbeatCommand(id, owner, token, leaseMs) { return this.writer.request({ type: "heartbeatCommand", id, owner, token, leaseMs }, { priority: "control" }); }
+    durableQueueHealth() { return this.writer.request({ type: "durableQueueHealth" }, { priority: "control", timeoutMs: 500 }); }
+    status() {
+        const writer = this.writer.status();
+        const reader = this.reader?.status();
+        return { ready: writer.ready && (!reader || reader.ready), closed: writer.closed && (!reader || reader.closed), restarts: { writer: this.writerRestarts, reader: this.readerRestarts }, writer, reader };
+    }
+    async close() {
+        this.closed = true;
+        await Promise.all([this.writerClient.close(), this.reader?.close()]);
+    }
+}

package/dist/data/async-telemetry-maintenance.js

@@ -0,0 +1,9 @@
+import { BoundedWorkerClient } from "./bounded-worker-client.js";
+export class AsyncTelemetryMaintenance {
+    client;
+    constructor(path) { this.client = new BoundedWorkerClient(new URL("./telemetry-maintenance-worker.js", import.meta.url), { maxPending: 8, maxPendingBytes: 64 * 1024, maxMessageBytes: 16 * 1024, maxAgeMs: 2000, workerOptions: { workerData: { path } } }); }
+    command(action, cutoff) { return this.client.request({ action, cutoff }, { priority: "control" }); }
+    preview(cutoff) { return this.client.request({ action: "preview", cutoff }, { priority: "background" }); }
+    status() { return this.client.status(); }
+    close() { return this.client.close(); }
+}