evolcore 0.0.1 → 0.0.2

package/dist/trigger/feedback.js

@@ -0,0 +1,685 @@
+import { buildEnvelope } from '../core/message/message-utils.js';
+import { renderTemplate, previewText, sha256 } from './validation.js';
+const FEEDBACK_DEADLINE_MS = 30_000;
+const TARGET_SESSION_DEADLINE_MS = 30 * 60_000;
+const TARGET_SESSION_CANCEL_GRACE_MS = 1_000;
+export class TriggerFeedbackDispatcher {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async dispatch(input) {
+        const feedback = this.auditFeedback(input.trigger, input.branch);
+        const renderedText = this.renderFeedbackText(input);
+        feedback.renderedTextHash = sha256(renderedText);
+        feedback.renderedTextPreview = previewText(renderedText);
+        if (input.trigger.feedback.strategy === 'silent' || !renderedText.trim()) {
+            return {
+                status: statusFromReply(input.reply),
+                reason: reasonFromReply(input.reply),
+                feedback,
+                effects: [],
+                error: errorFromReply(input.reply),
+                dryRunText: renderedText,
+            };
+        }
+        const target = this.resolveDeliveryTarget(input.trigger);
+        if (!target)
+            return this.failed(feedback, [], 'target_missing', 'trigger feedback target is missing');
+        feedback.target = target;
+        if (input.dryRun) {
+            return { status: 'dry-run', feedback, effects: [], error: null, dryRunText: renderedText };
+        }
+        const result = await this.dispatchDirect(input, renderedText, target);
+        if (result.error)
+            return { status: 'failed', reason: result.error.code, feedback, effects: result.effects, error: result.error };
+        return {
+            status: statusFromReply(input.reply),
+            reason: reasonFromReply(input.reply),
+            feedback,
+            effects: result.effects,
+            error: errorFromReply(input.reply),
+        };
+    }
+    async dispatchTargetSession(input) {
+        const feedback = this.auditFeedback(input.trigger);
+        const target = this.resolveDeliveryTarget(input.trigger);
+        if (!target)
+            return this.failed(feedback, [], 'target_missing', 'target_session feedback target is missing');
+        feedback.target = target;
+        feedback.renderedTextHash = sha256(input.prompt);
+        feedback.renderedTextPreview = previewText(input.prompt);
+        if (input.dryRun) {
+            return { status: 'completed', feedback, effects: [], error: null };
+        }
+        const delivery = new AbortController();
+        let abortKind;
+        const abortDelivery = (kind, reason) => {
+            if (delivery.signal.aborted)
+                return;
+            abortKind = kind;
+            delivery.abort(reason);
+        };
+        const onInputAbort = () => abortDelivery('cancelled', input.signal?.reason instanceof Error
+            ? input.signal.reason
+            : new Error('target session delivery cancelled'));
+        input.signal?.addEventListener('abort', onInputAbort, { once: true });
+        if (input.signal?.aborted)
+            onInputAbort();
+        const deadlineTimer = setTimeout(() => abortDelivery('timeout', new Error(`target session timed out after ${TARGET_SESSION_DEADLINE_MS}ms`)), TARGET_SESSION_DEADLINE_MS);
+        deadlineTimer.unref?.();
+        let outcome;
+        try {
+            if (delivery.signal.aborted) {
+                const aborted = targetSessionCancellationError(abortKind, delivery.signal.reason, false);
+                return this.failed(feedback, [], aborted.code, aborted.message);
+            }
+            const binding = this.deps.getChannel(input.trigger.agentAid, target.channelKey);
+            if (!binding) {
+                return this.failed(feedback, [], 'channel_not_configured', `agent ${input.trigger.agentAid} has no channel ${target.channelKey}`);
+            }
+            const startedAt = Date.now();
+            const channelType = channelTypeFromKey(target.channelKey);
+            let session;
+            try {
+                const existingLookup = target.session === 'thread'
+                    ? target.threadId && this.deps.sessionManager.getThreadSession
+                        ? this.deps.sessionManager.getThreadSession(target.channelKey, target.channelId, target.threadId)
+                        : undefined
+                    : this.deps.sessionManager.getActiveSession
+                        ? this.deps.sessionManager.getActiveSession(target.channelKey, target.channelId)
+                        : undefined;
+                const existing = existingLookup === undefined
+                    ? undefined
+                    : await raceWithAbort(Promise.resolve(existingLookup), delivery.signal);
+                if (existing) {
+                    session = existing;
+                }
+                else if (target.session === 'thread') {
+                    if (!target.threadId) {
+                        return this.failed(feedback, [], 'target_missing', 'target thread id is missing');
+                    }
+                    const mainLookup = this.deps.sessionManager.getActiveSession?.(target.channelKey, target.channelId);
+                    const main = mainLookup === undefined
+                        ? undefined
+                        : await raceWithAbort(Promise.resolve(mainLookup), delivery.signal);
+                    const mainMetadata = main?.metadata;
+                    const chatType = main?.chatType === 'group' ? 'group' : 'private';
+                    const peerId = mainMetadata?.peerId ?? `trigger:${input.trigger.id}`;
+                    const peerType = mainMetadata?.peerType ?? 'system';
+                    session = await raceWithAbort(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, main?.projectPath ?? binding.projectPath, target.threadId, {
+                        channelKey: mainMetadata?.channelKey ?? target.channelKey,
+                        peerId,
+                        peerName: mainMetadata?.peerName ?? input.trigger.name,
+                        peerType,
+                        ...(mainMetadata?.groupId ? { groupId: mainMetadata.groupId } : {}),
+                        ...(mainMetadata?.groupName ? { groupName: mainMetadata.groupName } : {}),
+                        replyContext: replyContextFromTarget(target),
+                    }, input.trigger.name, peerId, chatType, main?.baseagent ?? binding.baseagent, main?.selfAID ?? input.trigger.agentAid, main?.channelType ?? channelType, peerType), delivery.signal);
+                }
+                else {
+                    session = await raceWithAbort(this.deps.sessionManager.getOrCreateSession(target.channelKey, target.channelId, binding.projectPath, undefined, { channelKey: target.channelKey, peerId: `trigger:${input.trigger.id}`, peerName: input.trigger.name }, input.trigger.name, undefined, 'private', binding.baseagent, input.trigger.agentAid, channelType, 'system'), delivery.signal);
+                }
+            }
+            catch (err) {
+                if (delivery.signal.aborted) {
+                    const aborted = targetSessionCancellationError(abortKind, delivery.signal.reason, false);
+                    return this.failed(feedback, [], aborted.code, aborted.message);
+                }
+                return this.failed(feedback, [], 'session_error', err?.message || String(err));
+            }
+            const message = {
+                channel: target.channelKey,
+                channelType,
+                channelId: target.channelId,
+                selfAID: input.trigger.agentAid,
+                baseagent: session.baseagent || binding.baseagent,
+                threadId: session.threadId || '',
+                chatType: session.chatType === 'group' ? 'group' : 'private',
+                peerId: `trigger:${input.trigger.id}`,
+                peerName: input.trigger.name,
+                peerType: 'system',
+                content: input.prompt,
+                messageId: input.attemptId,
+                timestamp: Date.now(),
+                source: 'trigger',
+                causation: input.causation,
+                triggerMeta: {
+                    triggerId: input.trigger.id,
+                    runId: input.runId,
+                    attemptId: input.attemptId,
+                    triggerName: input.trigger.name,
+                    fireTime: input.firedAt,
+                    boundSessionId: session.id,
+                    modelOverride: input.trigger.execution.model,
+                    effortOverride: input.trigger.execution.effort,
+                    permissionModeOverride: input.trigger.execution.permissionMode,
+                    originPeerId: input.trigger.origin?.peerId,
+                    originChannelKey: input.trigger.origin?.channelKey,
+                    originChannelType: input.trigger.origin?.channelType
+                        ?? (input.trigger.origin?.channelKey ? channelTypeFromKey(input.trigger.origin.channelKey) : undefined),
+                    originControl: input.trigger.origin?.channelKey === 'daemon',
+                },
+            };
+            outcome = this.waitForTriggerOutcome(input.runId, input.attemptId, delivery.signal);
+            let enqueuePromise;
+            let event;
+            try {
+                enqueuePromise = this.deps.messageQueue.enqueue(session.id, message, session.projectPath, {
+                    interruptible: false,
+                    agentName: binding.agentName,
+                    sessionKeyField: session.sessionKey,
+                    selfAID: input.trigger.agentAid,
+                    signal: delivery.signal,
+                });
+                if (outcome) {
+                    const enqueueFailure = new Promise((_, reject) => {
+                        void enqueuePromise.catch(reject);
+                    });
+                    event = await Promise.race([outcome.promise, enqueueFailure]);
+                }
+                else {
+                    await raceWithAbort(enqueuePromise, delivery.signal);
+                }
+                if (abortKind) {
+                    const barrierSettled = await settleWithin(enqueuePromise, TARGET_SESSION_CANCEL_GRACE_MS);
+                    const aborted = targetSessionCancellationError(abortKind, delivery.signal.reason, !barrierSettled);
+                    return {
+                        status: 'failed',
+                        reason: aborted.code,
+                        feedback,
+                        effects: [this.inboundEffect('failed', target, session.id, startedAt, undefined, aborted.message)],
+                        error: aborted,
+                    };
+                }
+                if (event?.type === 'trigger:failed') {
+                    return {
+                        status: 'failed',
+                        reason: event.phase,
+                        feedback,
+                        effects: [this.inboundEffect('success', target, session.id, startedAt)],
+                        error: { code: event.phase || 'target_session_failed', message: event.error },
+                    };
+                }
+                if (event?.type === 'trigger:skipped') {
+                    return {
+                        status: 'failed',
+                        reason: event.reason,
+                        feedback,
+                        effects: [this.inboundEffect('success', target, session.id, startedAt)],
+                        error: { code: event.reason || 'target_session_skipped', message: event.reason || 'target session skipped' },
+                    };
+                }
+                return {
+                    status: 'completed',
+                    feedback,
+                    effects: [this.inboundEffect('success', target, session.id, startedAt, event?.messageId)],
+                    error: null,
+                };
+            }
+            catch (err) {
+                if (delivery.signal.aborted) {
+                    const barrierSettled = enqueuePromise
+                        ? await settleWithin(enqueuePromise, TARGET_SESSION_CANCEL_GRACE_MS)
+                        : true;
+                    const aborted = targetSessionCancellationError(abortKind, delivery.signal.reason, !barrierSettled);
+                    return {
+                        status: 'failed',
+                        reason: aborted.code,
+                        feedback,
+                        effects: [this.inboundEffect('failed', target, session.id, startedAt, undefined, aborted.message)],
+                        error: aborted,
+                    };
+                }
+                return {
+                    status: 'failed',
+                    reason: 'enqueue_error',
+                    feedback,
+                    effects: [this.inboundEffect('failed', target, session.id, startedAt, undefined, err?.message || String(err))],
+                    error: { code: 'enqueue_error', message: err?.message || String(err) },
+                };
+            }
+        }
+        finally {
+            clearTimeout(deadlineTimer);
+            input.signal?.removeEventListener('abort', onInputAbort);
+            outcome?.cancel();
+        }
+    }
+    renderFeedbackText(input) {
+        const template = input.branch && input.trigger.execution.type === 'script'
+            ? branchTemplate(input.trigger, input.branch)
+            : defaultResultTemplate(input.reply);
+        return renderTemplate(template, {
+            trigger: input.trigger,
+            reply: replyTemplateObject(input.reply),
+            error: input.reply.error ? { code: input.reply.error.reason, message: input.reply.error.text } : undefined,
+            event: input.sourcePayload,
+            source: input.sourcePayload ? { type: input.trigger.source.type, payload: input.sourcePayload } : undefined,
+            timestamp: input.firedAt,
+        });
+    }
+    auditFeedback(trigger, branch) {
+        const strategy = trigger.feedback.strategy;
+        return {
+            ...(trigger.execution.type === 'script' && strategy !== 'silent' && branch ? { branch } : {}),
+            strategy,
+            ...(strategy === 'target' && trigger.feedback.target
+                ? { target: trigger.feedback.target }
+                : strategy === 'origin' && trigger.origin
+                    ? { target: originAsTarget(trigger.origin) }
+                    : {}),
+        };
+    }
+    resolveDeliveryTarget(trigger) {
+        if (trigger.feedback.strategy === 'silent')
+            return undefined;
+        if (trigger.feedback.strategy === 'target')
+            return trigger.feedback.target;
+        return trigger.origin ? originAsTarget(trigger.origin) : undefined;
+    }
+    async dispatchDirect(input, text, target) {
+        const binding = this.deps.getChannel(input.trigger.agentAid, target.channelKey);
+        if (!binding)
+            return { effects: [], error: { code: 'channel_not_configured', message: `agent ${input.trigger.agentAid} has no channel ${target.channelKey}` } };
+        const effects = [];
+        const cancellation = feedbackCancellation(input.signal, FEEDBACK_DEADLINE_MS);
+        let attempt = 0;
+        try {
+            if (cancellation.signal.aborted)
+                return { effects, error: cancellation.error() };
+            if (this.deps.tryHandoff) {
+                const startedAt = Date.now();
+                try {
+                    const routed = await raceWithAbort(this.deps.tryHandoff({ ...input, signal: cancellation.signal }, text, target, binding), cancellation.signal);
+                    if (routed) {
+                        effects.push({
+                            type: 'handoff.enqueue',
+                            status: 'success',
+                            channelKey: target.channelKey,
+                            channelType: channelTypeFromKey(target.channelKey),
+                            channelId: target.channelId,
+                            sessionId: routed.targetSessionId,
+                            handoffId: routed.handoffId,
+                            attempt: ++attempt,
+                            startedAt,
+                            finishedAt: Date.now(),
+                        });
+                        return { effects, error: null };
+                    }
+                }
+                catch (err) {
+                    effects.push({
+                        type: 'handoff.enqueue',
+                        status: 'failed',
+                        channelKey: target.channelKey,
+                        channelType: channelTypeFromKey(target.channelKey),
+                        channelId: target.channelId,
+                        attempt: ++attempt,
+                        startedAt,
+                        finishedAt: Date.now(),
+                        error: err?.message || String(err),
+                    });
+                    if (cancellation.signal.aborted) {
+                        return { effects, error: cancellation.error() };
+                    }
+                }
+            }
+            while (!cancellation.signal.aborted) {
+                attempt += 1;
+                const startedAt = Date.now();
+                try {
+                    const isAunTarget = channelTypeFromKey(target.channelKey) === 'aun';
+                    await raceWithAbort(binding.adapter.send(buildEnvelope({
+                        taskId: `trigger:${input.runId}`,
+                        channel: binding.adapter.channelKey,
+                        channelId: target.channelId,
+                        agentName: binding.agentName,
+                        replyContext: isAunTarget
+                            ? replyContextWithCausation(target, input.causation)
+                            : replyContextFromTarget(target),
+                        causation: isAunTarget ? input.causation : undefined,
+                    }), {
+                        kind: 'result.text',
+                        text,
+                        isFinal: true,
+                        format: 'plain',
+                    }), cancellation.signal);
+                    effects.push({
+                        type: 'message.send',
+                        status: 'success',
+                        channelKey: target.channelKey,
+                        channelType: channelTypeFromKey(target.channelKey),
+                        channelId: target.channelId,
+                        attempt,
+                        startedAt,
+                        finishedAt: Date.now(),
+                    });
+                    return { effects, error: null };
+                }
+                catch (err) {
+                    if (cancellation.signal.aborted) {
+                        const aborted = cancellation.error();
+                        effects.push({
+                            type: 'message.send',
+                            status: 'failed',
+                            channelKey: target.channelKey,
+                            channelType: channelTypeFromKey(target.channelKey),
+                            channelId: target.channelId,
+                            attempt,
+                            startedAt,
+                            finishedAt: Date.now(),
+                            error: aborted.message,
+                        });
+                        return { effects, error: aborted };
+                    }
+                    const classified = this.classifySendError(err);
+                    effects.push({
+                        type: 'message.send',
+                        status: 'failed',
+                        channelKey: target.channelKey,
+                        channelType: channelTypeFromKey(target.channelKey),
+                        channelId: target.channelId,
+                        attempt,
+                        startedAt,
+                        finishedAt: Date.now(),
+                        error: classified.message,
+                    });
+                    if (!classified.retryable)
+                        return { effects, error: { code: classified.code, message: classified.message } };
+                    const backoffCompleted = await sleep(1_000, cancellation.signal);
+                    if (!backoffCompleted)
+                        return { effects, error: cancellation.error() };
+                }
+            }
+            return { effects, error: cancellation.error() };
+        }
+        finally {
+            cancellation.dispose();
+        }
+    }
+    inboundEffect(status, target, sessionId, startedAt, messageId, error) {
+        return {
+            type: 'message.inbound',
+            status,
+            channelKey: target.channelKey,
+            channelType: channelTypeFromKey(target.channelKey),
+            channelId: target.channelId,
+            sessionId,
+            messageId,
+            attempt: 1,
+            startedAt,
+            finishedAt: Date.now(),
+            error,
+        };
+    }
+    waitForTriggerOutcome(runId, attemptId, signal) {
+        if (!this.deps.eventBus)
+            return undefined;
+        let cancel = () => { };
+        const promise = new Promise(resolve => {
+            let settled = false;
+            const finish = (event) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.deps.eventBus?.unsubscribe('trigger:completed', onEvent);
+                this.deps.eventBus?.unsubscribe('trigger:failed', onEvent);
+                this.deps.eventBus?.unsubscribe('trigger:skipped', onEvent);
+                signal?.removeEventListener('abort', onAbort);
+                resolve(event);
+            };
+            const onEvent = (event) => {
+                if ((event.type === 'trigger:completed' || event.type === 'trigger:failed' || event.type === 'trigger:skipped')
+                    && event.runId === runId
+                    && event.attemptId === attemptId) {
+                    finish(event);
+                }
+            };
+            const onAbort = () => {
+                finish({
+                    type: 'trigger:failed',
+                    triggerId: '',
+                    name: '',
+                    runId,
+                    attemptId,
+                    originTriggerId: '',
+                    messageId: runId,
+                    error: signal?.reason instanceof Error
+                        ? signal.reason.message
+                        : 'target session delivery cancelled',
+                    targetChannel: '',
+                    targetChannelId: '',
+                    fireTime: Date.now(),
+                    phase: 'execute',
+                });
+            };
+            this.deps.eventBus?.subscribe('trigger:completed', onEvent);
+            this.deps.eventBus?.subscribe('trigger:failed', onEvent);
+            this.deps.eventBus?.subscribe('trigger:skipped', onEvent);
+            signal?.addEventListener('abort', onAbort, { once: true });
+            if (signal?.aborted)
+                onAbort();
+            cancel = () => finish();
+        });
+        return { promise, cancel: () => cancel() };
+    }
+    failed(feedback, effects, code, message) {
+        return {
+            status: 'failed',
+            reason: code,
+            feedback,
+            effects,
+            error: { code, message },
+        };
+    }
+    classifySendError(err) {
+        const message = err?.message || String(err);
+        const status = Number(err?.status ?? err?.statusCode ?? err?.code);
+        const rawCode = String(err?.code ?? err?.errorCode ?? '').toLowerCase();
+        const lower = `${message} ${rawCode}`.toLowerCase();
+        if (status === 408 || status === 429 || status >= 500) {
+            return { retryable: true, code: 'send_retryable_error', message };
+        }
+        if (status >= 400 && status < 500) {
+            return { retryable: false, code: 'send_permanent_error', message };
+        }
+        const retryablePatterns = [
+            'timeout', 'timed out', 'rate limit', 'too many requests', 'temporarily',
+            'temporary', 'network', 'disconnect', 'disconnected', 'not connected',
+            'econnreset', 'econnrefused', 'etimedout', 'eai_again', 'socket hang up',
+            'gateway', 'service unavailable',
+        ];
+        if (retryablePatterns.some(pattern => lower.includes(pattern))) {
+            return { retryable: true, code: 'send_retryable_error', message };
+        }
+        const permanentPatterns = [
+            'auth', 'unauthorized', 'forbidden', 'permission', 'invalid', 'bad request',
+            'not found', 'unknown receiver', 'user not found', 'chat not found',
+            'peer not found', 'target not found', 'not configured', 'unsupported',
+        ];
+        if (permanentPatterns.some(pattern => lower.includes(pattern))) {
+            return { retryable: false, code: 'send_permanent_error', message };
+        }
+        return { retryable: true, code: 'send_retryable_error', message };
+    }
+}
+function replyTemplateObject(reply) {
+    return {
+        outcome: reply.outcome,
+        text: reply.text,
+        files: reply.files,
+        meta: reply.meta,
+        error: reply.error,
+    };
+}
+function branchTemplate(trigger, branch) {
+    const value = trigger.feedback[branch]?.template;
+    if (value !== undefined)
+        return value;
+    if (branch === 'onReply')
+        return '{{reply.text}}';
+    if (branch === 'onNoop')
+        return '';
+    return '触发器失败：{{error.message}}';
+}
+function defaultResultTemplate(reply) {
+    if (reply.outcome === 'success')
+        return '{{reply.text}}';
+    if (reply.outcome === 'noop')
+        return '';
+    return '触发器失败：{{error.message}}';
+}
+function statusFromReply(reply) {
+    if (reply.outcome === 'success') {
+        return reply.anomalies?.length ? 'degraded' : 'completed';
+    }
+    if (reply.outcome === 'noop')
+        return 'noop';
+    return 'failed';
+}
+function reasonFromReply(reply) {
+    if (reply.outcome === 'noop')
+        return 'noop';
+    if (reply.outcome === 'timeout')
+        return 'timeout';
+    if (reply.outcome === 'interrupted')
+        return 'interrupted';
+    if (reply.outcome === 'error')
+        return reply.error?.reason ?? 'reply_error';
+    return undefined;
+}
+function errorFromReply(reply) {
+    if (reply.outcome !== 'error' && reply.outcome !== 'timeout' && reply.outcome !== 'interrupted')
+        return null;
+    return {
+        code: reply.error?.reason ?? reply.outcome,
+        message: reply.error?.text ?? reply.outcome,
+    };
+}
+function originAsTarget(origin) {
+    return {
+        channelKey: origin.channelKey,
+        channelId: origin.channelId,
+        session: origin.session,
+        threadId: origin.threadId,
+    };
+}
+function replyContextFromTarget(target) {
+    if (target.session !== 'thread' || !target.threadId)
+        return undefined;
+    return { threadId: target.threadId };
+}
+function replyContextWithCausation(target, causation) {
+    const base = replyContextFromTarget(target);
+    return {
+        ...(base ?? {}),
+        metadata: { ...(base?.metadata ?? {}), causation },
+    };
+}
+function channelTypeFromKey(channelKey) {
+    const idx = channelKey.indexOf('#');
+    return idx > 0 ? channelKey.slice(0, idx) : channelKey;
+}
+function feedbackCancellation(parent, timeoutMs) {
+    const controller = new AbortController();
+    let kind;
+    const onParentAbort = () => {
+        if (controller.signal.aborted)
+            return;
+        kind = 'cancelled';
+        controller.abort(parent?.reason instanceof Error
+            ? parent.reason
+            : new Error('trigger feedback cancelled'));
+    };
+    parent?.addEventListener('abort', onParentAbort, { once: true });
+    if (parent?.aborted)
+        onParentAbort();
+    const timer = setTimeout(() => {
+        if (controller.signal.aborted)
+            return;
+        kind = 'timeout';
+        controller.abort(new Error(`direct feedback timed out after ${timeoutMs}ms`));
+    }, Math.max(0, timeoutMs));
+    timer.unref?.();
+    return {
+        signal: controller.signal,
+        error: () => ({
+            code: kind === 'timeout' ? 'feedback_timeout' : 'cancelled',
+            message: controller.signal.reason instanceof Error
+                ? controller.signal.reason.message
+                : kind === 'timeout'
+                    ? `direct feedback timed out after ${timeoutMs}ms`
+                    : 'trigger feedback cancelled',
+        }),
+        dispose: () => {
+            clearTimeout(timer);
+            parent?.removeEventListener('abort', onParentAbort);
+        },
+    };
+}
+function targetSessionCancellationError(kind, reason, barrierTimedOut) {
+    const code = kind === 'timeout' ? 'target_session_timeout' : 'cancelled';
+    const base = kind === 'timeout'
+        ? `target session timed out after ${TARGET_SESSION_DEADLINE_MS}ms`
+        : reason instanceof Error
+            ? reason.message
+            : 'target session delivery cancelled';
+    return {
+        code,
+        message: barrierTimedOut
+            ? `${base}; interrupt barrier did not settle within ${TARGET_SESSION_CANCEL_GRACE_MS}ms`
+            : base,
+    };
+}
+function raceWithAbort(promise, signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            callback();
+        };
+        const onAbort = () => finish(() => reject(signal.reason instanceof Error ? signal.reason : new Error('operation cancelled')));
+        promise.then(value => finish(() => resolve(value)), error => finish(() => reject(error)));
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
+function settleWithin(promise, timeoutMs) {
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(false), Math.max(0, timeoutMs));
+        timer.unref?.();
+        promise.then(() => finish(true), () => finish(true));
+    });
+}
+function sleep(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve(false);
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (completed) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            resolve(completed);
+        };
+        const onAbort = () => finish(false);
+        const timer = setTimeout(() => finish(true), Math.max(0, ms));
+        timer.unref?.();
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}