@juspay/neurolink 12.17.1 → 12.17.2

package/dist/constants/contextWindows.d.ts

@@ -52,6 +52,8 @@ export declare function registerRuntimeOutputCeiling(provider: string, model: st
  * undefined when the serving infrastructure has not advertised one.
  */
 export declare function getRuntimeOutputCeiling(provider: string, model?: string): number | undefined;
+/** Remove a model ceiling that discovery no longer advertises as valid. */
+export declare function clearRuntimeOutputCeiling(provider: string, model: string): void;
 /** Test hook: clear runtime-discovered output ceilings (state is module-global). */
 export declare function clearRuntimeOutputCeilings(): void;
 /**

package/dist/constants/contextWindows.js

@@ -425,6 +425,10 @@ export function getRuntimeOutputCeiling(provider, model) {
     }
     return RUNTIME_OUTPUT_CEILINGS.get(`${provider}:${model}`);
 }
+/** Remove a model ceiling that discovery no longer advertises as valid. */
+export function clearRuntimeOutputCeiling(provider, model) {
+    RUNTIME_OUTPUT_CEILINGS.delete(`${provider}:${model}`);
+}
 /** Test hook: clear runtime-discovered output ceilings (state is module-global). */
 export function clearRuntimeOutputCeilings() {
     RUNTIME_OUTPUT_CEILINGS.clear();

package/dist/proxy/anthropicBudgetResponse.d.ts

@@ -0,0 +1,3 @@
+import type { ProxyTokenBudgetLease } from "../types/index.js";
+/** Observe consumed bytes only: no tee, eager draining, or unbounded SSE frame. */
+export declare function observeAnthropicBudgetResponse(response: Response, lease: ProxyTokenBudgetLease, onSettlement: () => void, signal?: AbortSignal): Response;

package/dist/proxy/anthropicBudgetResponse.js

@@ -0,0 +1,153 @@
+import { settleProxyTokenBudget } from "./proxyTokenBudget.js";
+/** Observe consumed bytes only: no tee, eager draining, or unbounded SSE frame. */
+export function observeAnthropicBudgetResponse(response, lease, onSettlement, signal) {
+    if (lease.snapshot.scope === "disabled") {
+        return response;
+    }
+    let finishing;
+    let terminalSeen = false;
+    let finalOutputUsageSeen = false;
+    let logicalFailureSeen = false;
+    let input;
+    let output;
+    let cachedRead = 0;
+    let cachedWrite = 0;
+    let pending = "";
+    let oversized = false;
+    const isSse = response.headers
+        .get("content-type")
+        ?.includes("text/event-stream");
+    const decoder = new TextDecoder();
+    const readUsage = (text) => {
+        try {
+            const event = JSON.parse(text);
+            if (event?.type === "message_stop") {
+                terminalSeen = true;
+            }
+            if (event?.type === "error") {
+                logicalFailureSeen = true;
+            }
+            const usage = event?.usage ?? event?.message?.usage;
+            if (!usage || typeof usage !== "object") {
+                return;
+            }
+            const valid = (n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0;
+            if (valid(usage.input_tokens)) {
+                input = Math.max(input ?? 0, usage.input_tokens);
+            }
+            if (valid(usage.output_tokens)) {
+                if (event?.type === "message_delta") {
+                    finalOutputUsageSeen = true;
+                }
+                output = Math.max(output ?? 0, usage.output_tokens);
+            }
+            if (valid(usage.cache_read_input_tokens)) {
+                cachedRead = Math.max(cachedRead, usage.cache_read_input_tokens);
+            }
+            if (valid(usage.cache_creation_input_tokens)) {
+                cachedWrite = Math.max(cachedWrite, usage.cache_creation_input_tokens);
+            }
+        }
+        catch {
+            /* Incomplete/oversized frames keep the conservative reservation. */
+        }
+    };
+    const observe = (text) => {
+        if (!isSse) {
+            if (!oversized && pending.length + text.length <= 1024 * 1024) {
+                pending += text;
+            }
+            else {
+                oversized = true;
+                pending = "";
+            }
+            return;
+        }
+        // Split large chunks without retaining a large frame between pulls.
+        for (const part of text.split(/(?<=\n)/u)) {
+            if (!oversized && pending.length + part.length <= 64 * 1024) {
+                pending += part;
+            }
+            else {
+                oversized = true;
+                pending = "";
+            }
+            if (part.endsWith("\n")) {
+                if (!oversized && pending.startsWith("data:")) {
+                    readUsage(pending.slice(5).trim());
+                }
+                pending = "";
+                oversized = false;
+            }
+        }
+    };
+    const finish = (normal) => {
+        if (finishing) {
+            return finishing;
+        }
+        finishing = (async () => {
+            signal?.removeEventListener("abort", onAbort);
+            if (normal) {
+                observe(decoder.decode());
+                if (!oversized && pending) {
+                    readUsage(isSse && pending.startsWith("data:")
+                        ? pending.slice(5).trim()
+                        : pending);
+                }
+            }
+            const actual = normal &&
+                !logicalFailureSeen &&
+                (!isSse || (terminalSeen && finalOutputUsageSeen)) &&
+                input !== undefined &&
+                output !== undefined
+                ? input + output + cachedRead + cachedWrite
+                : undefined;
+            try {
+                await settleProxyTokenBudget(lease, actual);
+            }
+            finally {
+                onSettlement();
+            }
+        })();
+        return finishing;
+    };
+    const onAbort = () => {
+        void finish(false).catch(() => undefined);
+    };
+    if (signal?.aborted) {
+        onAbort();
+    }
+    else {
+        signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    if (!response.body) {
+        void finish(false).catch(() => undefined);
+        return response;
+    }
+    const reader = response.body.getReader();
+    return new Response(new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await reader.read();
+                if (next.done) {
+                    await finish(true);
+                    controller.close();
+                    return;
+                }
+                observe(decoder.decode(next.value, { stream: true }));
+                controller.enqueue(next.value);
+            }
+            catch (error) {
+                await finish(false).catch(() => undefined);
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            await Promise.allSettled([reader.cancel(reason), finish(false)]);
+        },
+    }, { highWaterMark: 0 }), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}

package/dist/proxy/bodyCaptureProcessing.d.ts

@@ -10,6 +10,7 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     bytes?: number;
     truncated: boolean;
     originalBytes?: number;
+    unparseableFrames: number;
 };
 /**
  * Expose the same header-redaction policy to replay and metadata

package/dist/proxy/bodyCaptureProcessing.js

@@ -54,7 +54,7 @@ function redactNestedValue(key, value) {
         : value;
 }
 /** Redact every value under a sensitive key, including objects and arrays. */
-function redactBody(body) {
+function redactBody(body, redaction) {
     if (body === undefined || body === null) {
         return undefined;
     }
@@ -83,6 +83,7 @@ function redactBody(body) {
                         redacted = JSON.stringify(JSON.parse(data), redactNestedValue);
                     }
                     catch {
+                        redaction.unparseableFrames++;
                         redacted = "[UNPARSEABLE DATA REDACTED]";
                     }
                     return [
@@ -95,6 +96,7 @@ function redactBody(body) {
             // Invalid or truncated structured JSON must not expose an unterminated
             // credential value that a quoted-string regex cannot safely redact.
             if (/^\s*[[{]/.test(body)) {
+                redaction.unparseableFrames++;
                 return "[UNPARSEABLE DATA REDACTED]";
             }
             // Plain-text bodies retain the existing credential-field redaction.
@@ -175,13 +177,15 @@ export function splitUtf8StringByBytes(input, maxBytes) {
  * ceiling.
  */
 function prepareRedactedBody(body, maxBytes = MAX_CAPTURED_BODY_BYTES) {
-    const redacted = redactBody(body);
+    const redaction = { unparseableFrames: 0 };
+    const redacted = redactBody(body, redaction);
     if (redacted === undefined) {
-        return { truncated: false };
+        return { truncated: false, ...redaction };
     }
     return {
         ...truncateUtf8String(redacted, maxBytes),
         originalBytes: utf8ByteLength(redacted),
+        ...redaction,
     };
 }
 /**
@@ -251,11 +255,25 @@ export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
     const limit = logDir === null ? MAX_OTEL_CAPTURED_BODY_BYTES : MAX_CAPTURED_BODY_BYTES;
     const prepared = prepareRedactedBody(entry.body, limit);
-    prepared.truncated ||= entry.sourceTruncated === true;
+    // Structured objects no longer carry their wire byte representation. Do not
+    // serialize a second unredacted copy merely to manufacture a byte count.
+    const inputRetainedBytes = typeof entry.body === "string" ? utf8ByteLength(entry.body) : undefined;
+    const captureMetadata = {
+        sourceTruncated: entry.sourceTruncated === true,
+        processingTruncated: prepared.truncated,
+        inputRetainedBytes,
+        inputEncoding: typeof entry.body === "string"
+            ? "utf8_text"
+            : "structured_object",
+        redactionLossy: prepared.unparseableFrames > 0,
+        unparseableRedactedFrames: prepared.unparseableFrames,
+    };
+    prepared.truncated ||= captureMetadata.sourceTruncated;
     if (logDir === null) {
         return {
             headers,
             stored: {
+                ...captureMetadata,
                 redactedBody: prepared.value,
                 redactedBodyBytes: prepared.bytes,
                 bodyTruncated: prepared.truncated,
@@ -281,6 +299,7 @@ export async function processProxyBodyCapture(entry, logDir) {
         headers,
         stored: {
             ...stored,
+            ...captureMetadata,
             bodyCaptureLimitBytes: limit,
             originalRedactedBodyBytes: prepared.originalBytes,
         },

package/dist/proxy/bodyCaptureWorker.js

@@ -37,6 +37,7 @@ const snapshot = {
     rejectionReasons: {},
 };
 const pending = new Map();
+const publishingSince = new Map();
 const otelAdmissionWaiters = [];
 let admissionRetryTimer;
 /** Atomically reserve the active clone/publication lease. */
@@ -111,7 +112,7 @@ function waitForOtelAdmission(bytes) {
             drainOtelAdmissionWaiters();
         }, OTEL_ADMISSION_WAIT_MS);
         timer.unref?.();
-        otelAdmissionWaiters.push({ bytes, resolve, timer });
+        otelAdmissionWaiters.push({ bytes, queuedAt: Date.now(), resolve, timer });
     });
 }
 function releaseCapture(bytes) {
@@ -276,6 +277,7 @@ export async function captureProxyBody(entry, logDir, consume) {
         return consume({
             error,
             stored: { bodyWriteFailed: true },
+            admissionWaitMs: Math.max(0, Date.now() - queuedAt),
             admission: {
                 limitingResource: bytes > maxEntryBytes
                     ? "entry"
@@ -293,6 +295,7 @@ export async function captureProxyBody(entry, logDir, consume) {
             },
         });
     }
+    const admittedAt = Date.now();
     let current;
     try {
         current = getWorker();
@@ -312,14 +315,19 @@ export async function captureProxyBody(entry, logDir, consume) {
         timer.unref();
         pending.set(id, {
             timer,
+            startedAt: Date.now(),
             resolve: (result) => {
                 // Keep the byte/count lease through index writes and OTLP publication,
                 // so completed worker results cannot form an unbounded parent backlog.
+                publishingSince.set(id, Date.now());
+                result.admissionWaitMs = Math.max(0, admittedAt - queuedAt);
+                result.workerQueueWaitMs = Math.max(0, (result.queueWaitMs ?? 0) - result.admissionWaitMs);
                 void consume(result)
                     .catch(() => {
                     result.error ??= "body_capture_publication_failed";
                 })
                     .finally(() => {
+                    publishingSince.delete(id);
                     releaseCapture(bytes);
                     if (result.error || result.stored.bodyWriteFailed) {
                         snapshot.failed += 1;
@@ -351,7 +359,17 @@ export async function captureProxyBody(entry, logDir, consume) {
  * retained publication work.
  */
 export function getBodyCaptureWorkerSnapshot() {
-    return { ...snapshot, rejectionReasons: { ...snapshot.rejectionReasons } };
+    const now = Date.now();
+    const oldestAge = (times) => times.length ? Math.max(0, now - Math.min(...times)) : 0;
+    return {
+        ...snapshot,
+        rejectionReasons: { ...snapshot.rejectionReasons },
+        processing: pending.size,
+        publishing: publishingSince.size,
+        oldestAdmissionWaitMs: oldestAge(otelAdmissionWaiters.map((waiter) => waiter.queuedAt)),
+        oldestProcessingMs: oldestAge([...pending.values()].map((task) => task.startedAt)),
+        oldestPublicationMs: oldestAge([...publishingSince.values()]),
+    };
 }
 /** Isolated tests point at a separately executed built worker. */
 export const __bodyCaptureWorkerTestHooks = {

package/dist/proxy/codexFallback.d.ts

@@ -10,8 +10,18 @@ import type { ClaudeRequest, CodexFallbackResult, CodexFallbackStream, CodexReas
 export declare class CodexFallbackResponseError extends Error {
     readonly status: number;
     readonly responseBody: string;
+    readonly code?: string;
+    readonly retryable?: boolean;
     constructor(status: number, responseBody: string);
 }
+/** A provider terminal event, preserved through the format adapter. */
+export declare class CodexFallbackStreamError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly retryable?: boolean;
+    readonly usage?: CodexFallbackResult["usage"];
+    constructor(payload: Record<string, unknown>, eventType: string, usage?: CodexFallbackResult["usage"]);
+}
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
 export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model: string, reasoningEffort?: CodexReasoningEffort): CodexResponsesRequest;
 /**

package/dist/proxy/codexFallback.js

@@ -7,18 +7,88 @@
  * rules as a native Codex request.
  */
 import { ClaudeStreamSerializer, generateToolUseId } from "./claudeFormat.js";
+import { classifyProxyFailureCode } from "./proxyFailureDetails.js";
 import { extractCodexUsage } from "./codexUsage.js";
 import { proxyTokenUsage } from "./proxyTokenUsage.js";
+import { sanitizeForLog } from "../utils/logSanitize.js";
 export class CodexFallbackResponseError extends Error {
     status;
     responseBody;
+    code;
+    retryable;
     constructor(status, responseBody) {
         super(`Codex fallback request returned HTTP ${status}`);
         this.name = "CodexFallbackResponseError";
         this.status = status;
         this.responseBody = responseBody;
+        try {
+            const payload = JSON.parse(responseBody);
+            if (isRecord(payload)) {
+                const detail = streamFailureDetails(payload, "http_error");
+                this.code = detail.code;
+                this.retryable = detail.retryable;
+                if (detail.message) {
+                    this.message = detail.message;
+                }
+            }
+        }
+        catch {
+            // Non-JSON upstream responses retain the HTTP status without exposing HTML.
+        }
     }
 }
+/** A provider terminal event, preserved through the format adapter. */
+export class CodexFallbackStreamError extends Error {
+    status;
+    code;
+    retryable;
+    usage;
+    constructor(payload, eventType, usage) {
+        const detail = streamFailureDetails(payload, eventType);
+        super(detail.message ?? `Codex fallback stream terminated with ${eventType}`);
+        this.name = "CodexFallbackStreamError";
+        this.code = detail.code;
+        this.status = detail.status;
+        this.retryable = detail.retryable;
+        const observed = extractCodexUsage(payload);
+        this.usage = observed
+            ? {
+                ...proxyTokenUsage({
+                    inputTokens: observed.inputTokens,
+                    outputTokens: observed.outputTokens,
+                    reasoningTokens: observed.reasoningTokensObserved
+                        ? observed.reasoningTokens
+                        : undefined,
+                    cacheReadTokens: observed.cacheReadTokens,
+                    cacheCreationTokens: observed.cacheCreationTokens,
+                    inputIncludesCachedTokens: true,
+                }),
+                inputTokensObserved: observed.inputTokensObserved,
+                outputTokensObserved: observed.outputTokensObserved,
+            }
+            : usage;
+    }
+}
+function streamFailureDetails(payload, eventType) {
+    const response = isRecord(payload.response) ? payload.response : payload;
+    const error = isRecord(response.error) ? response.error : response;
+    const incomplete = isRecord(response.incomplete_details)
+        ? response.incomplete_details
+        : {};
+    const code = sanitizeForLog(asNonEmptyString(error.code) ??
+        asNonEmptyString(incomplete.reason) ??
+        eventType, 200);
+    const known = classifyProxyFailureCode(code);
+    return {
+        code,
+        status: known.status ?? 502,
+        retryable: known.retryable ??
+            (typeof error.retryable === "boolean" ? error.retryable : undefined),
+        message: typeof error.message === "string"
+            ? sanitizeForLog(error.message, 500)
+            : undefined,
+    };
+}
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -338,7 +408,7 @@ export function parseCodexFallbackSSE(sse) {
         if (type === "error" ||
             type === "response.failed" ||
             type === "response.incomplete") {
-            throw new Error(`Codex fallback stream terminated with ${type}`);
+            throw new CodexFallbackStreamError(payload, type, usage);
         }
         if (type === "response.output_text.delta") {
             if (typeof payload.delta !== "string") {
@@ -368,16 +438,20 @@ export function parseCodexFallbackSSE(sse) {
         }
         const parsedUsage = extractCodexUsage(payload);
         if (parsedUsage) {
-            usage = proxyTokenUsage({
-                inputTokens: parsedUsage.inputTokens,
-                outputTokens: parsedUsage.outputTokens,
-                reasoningTokens: parsedUsage.reasoningTokensObserved
-                    ? parsedUsage.reasoningTokens
-                    : undefined,
-                cacheReadTokens: parsedUsage.cacheReadTokens,
-                cacheCreationTokens: parsedUsage.cacheCreationTokens,
-                inputIncludesCachedTokens: true,
-            });
+            usage = {
+                ...proxyTokenUsage({
+                    inputTokens: parsedUsage.inputTokens,
+                    outputTokens: parsedUsage.outputTokens,
+                    reasoningTokens: parsedUsage.reasoningTokensObserved
+                        ? parsedUsage.reasoningTokens
+                        : undefined,
+                    cacheReadTokens: parsedUsage.cacheReadTokens,
+                    cacheCreationTokens: parsedUsage.cacheCreationTokens,
+                    inputIncludesCachedTokens: true,
+                }),
+                inputTokensObserved: parsedUsage.inputTokensObserved,
+                outputTokensObserved: parsedUsage.outputTokensObserved,
+            };
         }
         textFromResponse = outputTextFromResponse(payload);
     }
@@ -387,7 +461,10 @@ export function parseCodexFallbackSSE(sse) {
     const text = textFromDeltas || textFromCompletedItems || textFromResponse;
     const resolvedToolCalls = [...toolCalls.values()];
     if (!text && resolvedToolCalls.length === 0) {
-        throw new Error("Codex fallback returned no content or tool calls");
+        throw new CodexFallbackStreamError({
+            code: "empty_response",
+            message: "Codex fallback returned no content or tool calls",
+        }, "empty_response", usage);
     }
     return {
         text,
@@ -498,7 +575,7 @@ export async function createCodexFallbackStream(response, model) {
                 if (type === "error" ||
                     type === "response.failed" ||
                     type === "response.incomplete") {
-                    throw new Error(`Codex fallback stream terminated with ${type}`);
+                    throw new CodexFallbackStreamError(payload, type, usage);
                 }
                 const index = typeof payload.output_index === "number" ? payload.output_index : 0;
                 if (type === "response.output_text.delta") {
@@ -520,16 +597,20 @@ export async function createCodexFallbackStream(response, model) {
                     completed = true;
                     const parsedUsage = extractCodexUsage(payload);
                     if (parsedUsage) {
-                        usage = proxyTokenUsage({
-                            inputTokens: parsedUsage.inputTokens,
-                            outputTokens: parsedUsage.outputTokens,
-                            reasoningTokens: parsedUsage.reasoningTokensObserved
-                                ? parsedUsage.reasoningTokens
-                                : undefined,
-                            cacheReadTokens: parsedUsage.cacheReadTokens,
-                            cacheCreationTokens: parsedUsage.cacheCreationTokens,
-                            inputIncludesCachedTokens: true,
-                        });
+                        usage = {
+                            ...proxyTokenUsage({
+                                inputTokens: parsedUsage.inputTokens,
+                                outputTokens: parsedUsage.outputTokens,
+                                reasoningTokens: parsedUsage.reasoningTokensObserved
+                                    ? parsedUsage.reasoningTokens
+                                    : undefined,
+                                cacheReadTokens: parsedUsage.cacheReadTokens,
+                                cacheCreationTokens: parsedUsage.cacheCreationTokens,
+                                inputIncludesCachedTokens: true,
+                            }),
+                            inputTokensObserved: parsedUsage.inputTokensObserved,
+                            outputTokensObserved: parsedUsage.outputTokensObserved,
+                        };
                     }
                     const responseBody = payload.response;
                     if (isRecord(responseBody) && Array.isArray(responseBody.output)) {
@@ -573,7 +654,10 @@ export async function createCodexFallbackStream(response, model) {
                 throw new Error("Codex fallback stream ended before response.completed");
             }
             if (textLength === 0 && toolCalls.size === 0) {
-                throw new Error("Codex fallback returned no content or tool calls");
+                throw new CodexFallbackStreamError({
+                    code: "empty_response",
+                    message: "Codex fallback returned no content or tool calls",
+                }, "empty_response", usage);
             }
             const finishReason = toolCalls.size > 0 ? "tool_use" : "end_turn";
             yield* serializer.finish(usage?.output, finishReason, {

package/dist/proxy/codexUsage.js

@@ -104,6 +104,8 @@ export function extractCodexUsage(payload) {
     return {
         inputTokens: nonNegativeInt(input),
         outputTokens: nonNegativeInt(output),
+        inputTokensObserved: typeof input === "number" && Number.isFinite(input) && input >= 0,
+        outputTokensObserved: typeof output === "number" && Number.isFinite(output) && output >= 0,
         cacheReadTokens: nonNegativeInt(inputDetails?.cached_tokens),
         cacheCreationTokens: nonNegativeInt(inputDetails?.cache_write_tokens),
         reasoningTokens: nonNegativeInt(outputDetails?.reasoning_tokens),

package/dist/proxy/globalInstaller.d.ts

@@ -1,4 +1,4 @@
-import type { GlobalInstallerKind, GlobalInstallerResolution, InstalledVersionValidation, ResolveGlobalInstallerOptions, ValidateInstalledVersionOptions } from "../types/index.js";
+import type { ProxyServiceInstallSettings, ProxyPackageSelection, ProxyStagedInstallOptions, GlobalInstallerExecFile, GlobalInstallerKind, GlobalInstallerResolution, InstalledVersionValidation, ResolveGlobalInstallerOptions, ValidateInstalledVersionOptions } from "../types/index.js";
 /** Resolve a package manager that can update the installation currently running. */
 export declare function resolveGlobalInstaller(options?: ResolveGlobalInstallerOptions): GlobalInstallerResolution;
 export declare function getGlobalInstallArgs(kind: GlobalInstallerKind, packageSpec: string): string[];
@@ -17,3 +17,34 @@ export declare function isTransientInstallFailure(error: unknown): boolean;
  */
 export declare function validateInstalledVersion(options: ValidateInstalledVersionOptions): Promise<InstalledVersionValidation>;
 export declare function describeInstallFailure(error: unknown): string;
+/** Read package metadata without importing the CLI/provider/telemetry graph. */
+export declare function inspectProxyPackage(entryScript: string, nodePath?: string): ProxyPackageSelection;
+export declare function readProxyPackageSelection(packagesDir: string, previous?: boolean): ProxyPackageSelection | null;
+/** Resolve immutable selections before consulting an older mutable global entry. */
+export declare function resolveProxyWorkerPackage(options: {
+    packagesDir: string;
+    entryScript: string;
+    expectedVersion: string;
+}): ProxyPackageSelection;
+/** Persist only package selection; runtime env, config and launchd settings are untouched. */
+export declare function selectProxyPackage(packagesDir: string, selection: ProxyPackageSelection, isCurrentOwner?: () => boolean): void;
+/** No startup probes: IPC descriptors and OTel initialization belong to the real process. */
+export declare function writeProxyPackageLauncher(path: string, selection: ProxyPackageSelection, isCurrentOwner?: () => boolean): void;
+/** Install in a private tree, then publish the immutable directory after validation. */
+export declare function installStagedProxyPackage(options: ProxyStagedInstallOptions): Promise<ProxyPackageSelection>;
+/** Only operator runtime settings survive reinstall, never worker IPC identity. */
+export declare function isProxyServiceEnvironmentKey(name: string): boolean;
+/** Parse plutil JSON without exposing credentials or invoking the saved launcher. */
+export declare function parseProxyServiceInstallSettings(value: unknown): ProxyServiceInstallSettings;
+/** Distinguish an absent launchd job from permission failures without logging plist/env data. */
+export declare function probeProxyLaunchdPresence(options: {
+    label: string;
+    uid: number;
+    execFileSync?: GlobalInstallerExecFile;
+}): "loaded" | "not_loaded" | "unknown";
+/** Read-only guard: callers must run this before every reinstall mutation. */
+export declare function assertProxyServiceInstallIdle(options: {
+    pids: number[];
+    getProcessStatus: (pid: number) => "running" | "not_running" | "unknown";
+    launchdPresence: "loaded" | "not_loaded" | "unknown";
+}): void;