@undefineds.co/linx 0.3.5 → 0.3.8

package/dist/lib/pi-adapter/pod-approval.js

@@ -1,246 +1,418 @@
-import { linxRuntimeEndpointForBackend } from '../../../vendor/agent-runtime/dist/index.js';
-import { createFallbackAutoModeSecretaryRecommendation, isTrustedAutoModeCommand, resolveAutoModeAutoApprovalDecision, autoModeApprovalActionUri, autoModeApprovalRequestMessage, autoModeApprovalRisk, autoModeApprovalToolName, } from '../../../vendor/agent-runtime/dist/auto-mode.js';
-import { createRemoteApproval, requestRemoteApproval, resolveRemoteAutoModeApproval, } from '../auto-mode/pod-approval.js';
-import { resolveAutoModeSecretaryRecommendation } from '../auto-mode/secretary.js';
-import { buildAgentUri, buildThreadUri, DEFAULT_SECRETARY_CHAT_ID } from './pod-mirror-mapping.js';
-export function installLinxPiRemoteApproval(options) {
-    const agent = options.session.agent;
-    const originalBeforeToolCall = agent.beforeToolCall?.bind(agent);
-    agent.beforeToolCall = async (context, signal) => {
-        const originalResult = await originalBeforeToolCall?.(context, signal);
-        if (originalResult?.block) {
-            return originalResult;
-        }
-        const request = buildPiToolApprovalRequest(context, options.cwd);
-        if (!request) {
-            return originalResult;
-        }
-        const decision = await resolveLinxPiToolApproval({
-            request,
-            record: buildPiApprovalRecord(options, context),
-            mode: options.mode ?? 'smart',
-            pollMs: options.pollMs,
-            signal,
-            runtime: options.runtime,
-            resolveSecretaryRecommendation: options.resolveSecretaryRecommendation ?? resolveAutoModeSecretaryRecommendation,
-        });
-        return mapApprovalDecisionToBeforeToolCallResult(decision, request);
+import { randomUUID } from 'node:crypto';
+import { createRemoteApproval, resolveRemoteAutoModeApproval, waitForRemoteAutoModeApproval, } from '../auto-mode/pod-approval.js';
+import { DEFAULT_SECRETARY_CHAT_ID, secretaryAgentUri, secretaryThreadUri } from './pod-mirror-mapping.js';
+const EXTENSION_UI_POLICY_VERSION = 'linx-pi-extension-ui/v1';
+const DEFAULT_POLL_MS = 1000;
+const EXTENSION_UI_INPUT_QUESTION_ID = 'runtime';
+export function createPodBackedExtensionUiContext(baseUi, options = {}) {
+    return {
+        ...baseUi,
+        select(title, choices, opts) {
+            return selectWithPodApproval(baseUi, title, choices, opts, options);
+        },
+        confirm(title, message, opts) {
+            return confirmWithPodApproval(baseUi, title, message, opts, options);
+        },
+        input(title, placeholder, opts) {
+            return inputWithAutoSecretary(baseUi, title, placeholder, opts, options);
+        },
     };
 }
-export async function resolveLinxPiToolApproval(input) {
-    const fallbackDecision = resolvePiFallbackAutoDecision(input);
-    if (fallbackDecision) {
-        return fallbackDecision;
-    }
-    const rawRecommendation = await input.resolveSecretaryRecommendation({
-        mode: input.mode,
-        record: input.record,
-        request: input.request,
-    }).catch(() => createFallbackAutoModeSecretaryRecommendation({
-        mode: input.mode,
-        request: input.request,
-    }));
-    const recommendation = normalizePiApprovalRecommendation(input, rawRecommendation);
-    if (recommendation?.canAutoDecide && recommendation.decision && recommendation.source === 'model') {
-        return resolvePiRemoteApproval(input, recommendation);
+async function selectWithPodApproval(baseUi, title, choices, opts, options) {
+    if (opts?.signal?.aborted || choices.length === 0) {
+        return baseUi.select(title, choices, opts);
+    }
+    if (!shouldPodBackSelect(choices)) {
+        return baseUi.select(title, choices, opts);
     }
-    const autoDecision = resolvePiAutoDecision(input, recommendation);
-    if (autoDecision) {
-        return autoDecision;
+    const approvalOptions = choices.map((label, index) => buildSelectApprovalOption(label, index));
+    const autoResult = await resolveAutoSecretaryExtensionUiInput({
+        title,
+        kind: 'select',
+        choices,
+        approvalOptions,
+        timeoutMs: opts?.timeout,
+        options,
+        mapResponse: (response) => {
+            if (!response) {
+                return undefined;
+            }
+            if (response.kind === 'approval') {
+                return choiceFromRemoteDecision(response.decision, choices, approvalOptions);
+            }
+            const answer = response.answers[EXTENSION_UI_INPUT_QUESTION_ID]?.answers[0];
+            if (!answer) {
+                return undefined;
+            }
+            return choices.includes(answer) ? answer : undefined;
+        },
+    });
+    if (autoResult.resolved) {
+        return autoResult.value;
     }
-    return resolvePiRemoteApproval(input, recommendation)
-        .catch(() => 'decline');
+    const result = await raceLocalAndRemote({
+        title,
+        kind: 'select',
+        choices,
+        approvalOptions,
+        opts,
+        options,
+        runLocal: (signal) => baseUi.select(title, choices, { ...opts, signal }),
+        mapLocalToDecision: (selected) => podDecisionFromSelectedChoice(selected, approvalOptions),
+        mapRemoteToLocal: (decision) => choiceFromRemoteDecision(decision, choices, approvalOptions),
+        localResolutionNote: (selected) => selected
+            ? encodeExtensionUiNote({ kind: 'select', selectedOptionId: optionIdForChoice(selected, choices), selectedLabel: selected })
+            : encodeExtensionUiNote({ kind: 'select', cancelled: true }),
+    });
+    return result;
 }
-function normalizePiApprovalRecommendation(input, recommendation) {
-    if (!isApprovalRecommendation(input.request, recommendation)) {
-        return null;
+async function confirmWithPodApproval(baseUi, title, message, opts, options) {
+    if (opts?.signal?.aborted) {
+        return baseUi.confirm(title, message, opts);
+    }
+    const approvalOptions = [
+        { optionId: 'yes', label: 'Yes', kind: 'allow_once' },
+        { optionId: 'no', label: 'No', kind: 'reject_once' },
+    ];
+    const autoResult = await resolveAutoSecretaryExtensionUiInput({
+        title,
+        message,
+        kind: 'confirm',
+        choices: ['Yes', 'No'],
+        approvalOptions,
+        timeoutMs: opts?.timeout,
+        options,
+        mapResponse: (response) => {
+            if (!response) {
+                return undefined;
+            }
+            if (response.kind === 'approval') {
+                return response.decision === 'accept' || response.decision === 'accept_for_session';
+            }
+            const answer = response.answers[EXTENSION_UI_INPUT_QUESTION_ID]?.answers[0]?.toLowerCase();
+            if (!answer) {
+                return undefined;
+            }
+            if (['yes', 'y', 'true', 'allow', 'approve', 'confirm'].includes(answer)) {
+                return true;
+            }
+            if (['no', 'n', 'false', 'deny', 'decline', 'reject'].includes(answer)) {
+                return false;
+            }
+            return undefined;
+        },
+    });
+    if (autoResult.resolved) {
+        return autoResult.value ?? false;
+    }
+    const result = await raceLocalAndRemote({
+        title,
+        message,
+        kind: 'confirm',
+        choices: ['Yes', 'No'],
+        approvalOptions,
+        opts,
+        options,
+        runLocal: (signal) => baseUi.confirm(title, message, { ...opts, signal }),
+        mapLocalToDecision: (confirmed) => confirmed ? 'accept' : 'decline',
+        mapRemoteToLocal: (decision) => decision === 'accept' || decision === 'accept_for_session',
+        localResolutionNote: (confirmed) => encodeExtensionUiNote({
+            kind: 'confirm',
+            selectedOptionId: confirmed ? 'yes' : 'no',
+            selectedLabel: confirmed ? 'Yes' : 'No',
+        }),
+    });
+    return result ?? false;
+}
+async function inputWithAutoSecretary(baseUi, title, placeholder, opts, options) {
+    if (opts?.signal?.aborted) {
+        return baseUi.input(title, placeholder, opts);
+    }
+    const autoResult = await resolveAutoSecretaryExtensionUiInput({
+        title,
+        message: placeholder,
+        kind: 'input',
+        choices: [],
+        approvalOptions: [],
+        timeoutMs: opts?.timeout,
+        options,
+        mapResponse: (response) => {
+            if (!response) {
+                return undefined;
+            }
+            if (response.kind !== 'user-input') {
+                return undefined;
+            }
+            return response.answers[EXTENSION_UI_INPUT_QUESTION_ID]?.answers[0];
+        },
+    });
+    if (autoResult.resolved) {
+        return autoResult.value;
+    }
+    return baseUi.input(title, placeholder, opts);
+}
+async function resolveAutoSecretaryExtensionUiInput(input) {
+    const sessionControl = input.options.sessionControl;
+    if (!sessionControl) {
+        return { resolved: false };
     }
-    if (recommendation.source === 'fallback' && recommendation.canAutoDecide && !isTrustedPiFallbackApproval(input.request)) {
+    const request = buildExtensionUiInteractionRequest(input);
+    const response = await sessionControl.resolveInteractionRequest({ request });
+    if (!response) {
+        return { resolved: false };
+    }
+    const value = input.mapResponse(response);
+    return value === undefined ? { resolved: false } : { resolved: true, value };
+}
+function buildExtensionUiInteractionRequest(input) {
+    if (input.kind === 'input' || input.approvalOptions.length === 0) {
         return {
-            ...recommendation,
-            canAutoDecide: false,
-            decision: undefined,
+            kind: 'user-input',
+            message: [input.title, input.message].filter(Boolean).join('\n') || 'Input required',
+            questions: [buildExtensionUiQuestion(input)],
+            ...(input.timeoutMs ? { timeoutMs: input.timeoutMs } : {}),
+            raw: buildExtensionUiRaw(input),
         };
     }
-    return recommendation;
+    return {
+        kind: 'codex-approval',
+        message: [input.title, input.message].filter(Boolean).join('\n') || 'Approval required',
+        approvalOptions: input.approvalOptions,
+        ...(input.timeoutMs ? { timeoutMs: input.timeoutMs } : {}),
+        raw: buildExtensionUiRaw(input),
+    };
 }
-async function resolvePiRemoteApproval(input, recommendation) {
-    const subject = buildPiApprovalSubject(input.record);
-    const request = buildPiRemoteApprovalRequest(input.request);
-    if (recommendation?.canAutoDecide && recommendation.decision) {
-        const remote = await createRemoteApproval({
-            subject,
-            request,
-            runtime: input.runtime,
-        });
-        await resolveRemoteAutoModeApproval({
+function buildExtensionUiQuestion(input) {
+    return {
+        id: EXTENSION_UI_INPUT_QUESTION_ID,
+        header: input.kind === 'input' ? 'Input' : 'Select',
+        question: [input.title, input.message].filter(Boolean).join('\n') || 'Input required',
+        options: input.choices.map((label) => ({ label })),
+    };
+}
+function buildExtensionUiRaw(input) {
+    return {
+        source: 'pi-extension-ui',
+        kind: input.kind,
+        title: input.title,
+        ...(input.message ? { message: input.message } : {}),
+        choices: input.choices,
+        ...(input.options.cwd ? { cwd: input.options.cwd } : {}),
+        sessionId: resolveSessionId(input.options.sessionId),
+    };
+}
+async function raceLocalAndRemote(input) {
+    const localAbort = new AbortController();
+    const removeInputAbort = linkAbortSignal(input.opts?.signal, () => localAbort.abort());
+    const remoteAbort = new AbortController();
+    const removeRemoteAbort = linkAbortSignal(input.opts?.signal, () => remoteAbort.abort());
+    const localPromise = input.runLocal(localAbort.signal).then((value) => ({
+        source: 'local',
+        value,
+    }));
+    const remoteReadyPromise = createExtensionUiRemoteApproval({
+        title: input.title,
+        message: input.message,
+        kind: input.kind,
+        choices: input.choices,
+        approvalOptions: input.approvalOptions,
+        timeoutMs: input.opts?.timeout,
+        options: input.options,
+    }).catch((error) => {
+        input.options.onWarning?.(error);
+        return null;
+    });
+    const remotePromise = remoteReadyPromise.then(async (remote) => {
+        if (!remote) {
+            return { source: 'remote-unavailable' };
+        }
+        const decision = await waitForRemoteAutoModeApproval({
             approvalId: remote.id,
             approvalUri: remote.approvalUri,
-            decision: recommendation.decision,
-            decisionRole: 'secretary',
-            note: recommendation.reason ?? 'resolved by AI secretary',
-            runtime: input.runtime,
-        }).catch(() => undefined);
-        return recommendation.decision;
-    }
-    return requestRemoteApproval({
-        subject,
-        request,
-        pollMs: input.pollMs,
-        signal: input.signal,
-        runtime: input.runtime,
+            pollMs: input.options.pollMs ?? DEFAULT_POLL_MS,
+            signal: remoteAbort.signal,
+            runtime: input.options.runtime,
+        });
+        return {
+            source: 'remote',
+            value: input.mapRemoteToLocal(decision),
+        };
     });
+    void localPromise.catch(() => undefined);
+    void remotePromise.catch(() => undefined);
+    try {
+        const winner = await Promise.race([localPromise, remotePromise]);
+        if (winner.source === 'remote-unavailable') {
+            return (await localPromise).value;
+        }
+        if (winner.source === 'local') {
+            remoteAbort.abort();
+            void remoteReadyPromise.then((remote) => {
+                if (!remote) {
+                    return undefined;
+                }
+                return resolveRemoteAutoModeApproval({
+                    approvalId: remote.id,
+                    approvalUri: remote.approvalUri,
+                    decision: input.mapLocalToDecision(winner.value),
+                    decisionRole: 'human',
+                    note: input.localResolutionNote(winner.value),
+                    runtime: input.options.runtime,
+                });
+            }).catch((error) => input.options.onWarning?.(error));
+            return winner.value;
+        }
+        localAbort.abort();
+        return winner.value;
+    }
+    finally {
+        removeInputAbort();
+        removeRemoteAbort();
+    }
 }
-function buildPiApprovalSubject(record) {
-    return ({ webId }) => ({
-        sessionUri: buildThreadUri(webId, DEFAULT_SECRETARY_CHAT_ID, record.id),
-        actorUri: buildAgentUri(webId),
-        policyVersion: 'linx-pi-remote-approval/v1',
+async function createExtensionUiRemoteApproval(input) {
+    return createRemoteApproval({
+        subject: ({ webId }) => buildExtensionUiApprovalSubject(webId, input.options),
+        request: ({ sessionUri }) => buildExtensionUiApprovalRequest({
+            title: input.title,
+            message: input.message,
+            kind: input.kind,
+            choices: input.choices,
+            approvalOptions: input.approvalOptions,
+            sessionUri,
+            cwd: input.options.cwd,
+            timeoutMs: input.timeoutMs,
+        }),
+        runtime: input.options.runtime,
     });
 }
-function buildPiRemoteApprovalRequest(request) {
-    const details = buildLinxPiApprovalDetails(request);
+function buildExtensionUiApprovalSubject(webId, options) {
+    const sessionId = resolveSessionId(options.sessionId) ?? 'linx-pi-extension-ui';
+    const sessionUri = secretaryThreadUri(webId, sessionId, DEFAULT_SECRETARY_CHAT_ID);
     return {
-        kind: request.kind,
-        message: details.message,
-        toolCallId: extractPiToolCallId(request),
-        toolName: details.toolName,
-        action: details.action,
-        risk: details.risk,
-        ...(request.kind === 'command-approval' && request.command ? { command: request.command } : {}),
-        ...(request.kind === 'command-approval' && request.cwd ? { cwd: request.cwd } : {}),
+        sessionUri,
+        actorUri: secretaryAgentUri(webId),
+        target: sessionUri,
+        policyVersion: EXTENSION_UI_POLICY_VERSION,
     };
 }
-function extractPiToolCallId(request) {
-    const raw = isRecord(request.raw) ? request.raw : {};
-    const params = isRecord(raw.params) ? raw.params : {};
-    const toolCall = isRecord(params.toolCall) ? params.toolCall : {};
-    return typeof toolCall.toolCallId === 'string' && toolCall.toolCallId.trim()
-        ? toolCall.toolCallId.trim()
-        : `${autoModeApprovalToolName(request)}-${Date.now()}`;
-}
-function resolvePiAutoDecision(input, recommendation) {
-    if (recommendation?.canAutoDecide && recommendation.decision) {
-        if (recommendation.source === 'fallback' && !isTrustedPiFallbackApproval(input.request)) {
-            return null;
-        }
-        return recommendation.decision;
+function buildExtensionUiApprovalRequest(input) {
+    const prompt = [input.title, input.message].filter(Boolean).join('\n');
+    return {
+        kind: 'codex-approval',
+        message: prompt,
+        toolCallId: `extension-ui-${input.kind}-${randomUUID()}`,
+        toolName: `extension-ui-${input.kind}`,
+        action: 'https://undefineds.co/ns#runtimeApproval',
+        risk: 'medium',
+        approvalOptions: input.approvalOptions,
+        ...(input.timeoutMs ? { timeoutMs: input.timeoutMs } : {}),
+        context: JSON.stringify({
+            source: 'pi-extension-ui',
+            kind: input.kind,
+            title: input.title,
+            ...(input.message ? { message: input.message } : {}),
+            choices: input.choices,
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+        }),
+        entry: input.sessionUri,
+    };
+}
+function shouldPodBackSelect(choices) {
+    const inferred = choices.map((choice) => inferApprovalOptionKind(choice));
+    const hasAllow = inferred.some((kind) => kind === 'allow_once' || kind === 'allow_always');
+    const hasReject = inferred.some((kind) => kind === 'reject_once' || kind === 'reject_always' || kind === 'cancel');
+    return hasAllow && hasReject;
+}
+function buildSelectApprovalOption(label, index) {
+    const kind = inferApprovalOptionKind(label);
+    return {
+        optionId: String(index),
+        label,
+        ...(kind ? { kind } : {}),
+    };
+}
+function inferApprovalOptionKind(label) {
+    const normalized = label.toLowerCase();
+    if (/\b(always|session|trust)\b/u.test(normalized)) {
+        return 'allow_always';
+    }
+    if (/\b(allow|approve|yes|ok|confirm|proceed|continue)\b/u.test(normalized)) {
+        return 'allow_once';
+    }
+    if (/\b(cancel|escape)\b/u.test(normalized)) {
+        return 'cancel';
     }
-    return resolvePiFallbackAutoDecision(input);
+    if (/\b(block|deny|decline|reject|no)\b/u.test(normalized)) {
+        return 'reject_once';
+    }
+    return undefined;
 }
-function resolvePiFallbackAutoDecision(input) {
-    if (input.request.kind === 'command-approval') {
-        return resolveAutoModeAutoApprovalDecision({
-            mode: input.mode,
-            request: input.request,
-        });
+function decisionFromSelectedChoice(selected, approvalOptions) {
+    if (!selected) {
+        return 'cancel';
     }
-    if (input.mode === 'auto' && (input.request.kind === 'file-change-approval'
-        || input.request.kind === 'permissions-approval')) {
+    const option = approvalOptions.find((entry) => entry.label === selected);
+    if (option?.kind === 'allow_always') {
         return 'accept_for_session';
     }
-    return null;
-}
-function isTrustedPiFallbackApproval(request) {
-    return request.kind === 'command-approval' && isTrustedAutoModeCommand(request.command);
+    if (option?.kind === 'reject_once' || option?.kind === 'reject_always') {
+        return 'decline';
+    }
+    if (option?.kind === 'cancel') {
+        return 'cancel';
+    }
+    return 'accept';
 }
-function isApprovalRecommendation(request, recommendation) {
-    return Boolean(recommendation && recommendation.kind === request.kind);
+function podDecisionFromSelectedChoice(selected, approvalOptions) {
+    const decision = decisionFromSelectedChoice(selected, approvalOptions);
+    // Extension UI options belong to the extension, not LinX's reusable grant
+    // layer. Preserve the exact option in the note without creating a grant.
+    return decision === 'accept_for_session' ? 'accept' : decision;
 }
-function buildPiToolApprovalRequest(context, cwd) {
-    const toolName = typeof context.toolCall.name === 'string' ? context.toolCall.name : undefined;
-    if (!toolName) {
-        return null;
+function choiceFromRemoteDecision(decision, choices, approvalOptions) {
+    if (decision === 'cancel') {
+        return undefined;
     }
-    const toolCallId = typeof context.toolCall.id === 'string' && context.toolCall.id.trim()
-        ? context.toolCall.id.trim()
-        : `${toolName}-${Date.now()}`;
-    const raw = {
-        endpoint: linxRuntimeEndpointForBackend('linx'),
-        params: {
-            toolCall: {
-                toolCallId,
-                name: toolName,
-            },
-        },
-        piToolCall: context.toolCall,
-        args: context.args,
-    };
-    if (toolName === 'bash') {
-        const args = isRecord(context.args) ? context.args : {};
-        const command = typeof args.command === 'string' ? args.command : undefined;
-        return {
-            kind: 'command-approval',
-            message: command ? `Approve command: ${command}` : 'Approve bash command',
-            command,
-            cwd,
-            raw,
-        };
+    const preferredKinds = decision === 'accept_for_session'
+        ? ['allow_always', 'allow_once']
+        : decision === 'accept'
+            ? ['allow_once', 'allow_always']
+            : ['reject_once', 'reject_always', 'cancel'];
+    for (const kind of preferredKinds) {
+        const option = approvalOptions.find((entry) => entry.kind === kind);
+        if (option) {
+            return choices[Number(option.optionId)] ?? option.label;
+        }
     }
-    if (toolName === 'edit' || toolName === 'write') {
-        return {
-            kind: 'file-change-approval',
-            message: `Approve ${toolName} tool call`,
-            reason: summarizeToolArgs(toolName, context.args),
-            raw,
-        };
+    if (decision === 'decline') {
+        return undefined;
     }
-    return null;
+    return choices[0];
 }
-function buildPiApprovalRecord(options, context) {
-    const sessionId = getPiSessionId(options.session);
-    return {
-        id: sessionId,
-        backend: 'codex',
-        runtime: 'local',
-        transport: 'native',
-        mode: options.mode ?? 'smart',
-        cwd: options.cwd,
-        passthroughArgs: [],
-        credentialSource: 'cloud',
-        resolvedCredentialSource: 'cloud',
-        approvalSource: 'hybrid',
-        command: 'linx',
-        args: [],
-        status: 'running',
-        startedAt: new Date(context.assistantMessage.timestamp ?? Date.now()).toISOString(),
-        archiveDir: '',
-        eventsFile: '',
-    };
+function optionIdForChoice(selected, choices) {
+    const index = choices.findIndex((choice) => choice === selected);
+    return index >= 0 ? String(index) : undefined;
 }
-function getPiSessionId(session) {
-    const manager = session.sessionManager;
-    return manager?.getSessionId?.() || 'linx-pi-session';
+function encodeExtensionUiNote(value) {
+    return JSON.stringify({
+        source: 'pi-extension-ui',
+        ...value,
+    });
 }
-function mapApprovalDecisionToBeforeToolCallResult(decision, request) {
-    if (decision === 'accept' || decision === 'accept_for_session') {
-        return undefined;
-    }
-    return {
-        block: true,
-        reason: decision === 'cancel'
-            ? `LinX cancelled ${autoModeApprovalRequestMessage(request)}`
-            : `LinX denied ${autoModeApprovalRequestMessage(request)}`,
-    };
+function resolveSessionId(value) {
+    const resolved = typeof value === 'function' ? value() : value;
+    return typeof resolved === 'string' && resolved.trim() ? resolved.trim() : undefined;
 }
-function summarizeToolArgs(toolName, args) {
-    if (!isRecord(args)) {
-        return toolName;
+function linkAbortSignal(signal, onAbort) {
+    if (!signal) {
+        return () => undefined;
     }
-    const path = typeof args.path === 'string' ? args.path : undefined;
-    const filePath = typeof args.filePath === 'string' ? args.filePath : undefined;
-    const target = path ?? filePath;
-    return target ? `${toolName} ${target}` : toolName;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function buildLinxPiApprovalDetails(request) {
-    return {
-        message: autoModeApprovalRequestMessage(request),
-        toolName: autoModeApprovalToolName(request),
-        action: autoModeApprovalActionUri(request),
-        risk: autoModeApprovalRisk(request),
-    };
+    if (signal.aborted) {
+        onAbort();
+        return () => undefined;
+    }
+    signal.addEventListener('abort', onAbort, { once: true });
+    return () => signal.removeEventListener('abort', onAbort);
 }
 //# sourceMappingURL=pod-approval.js.map