@push.rocks/smartproxy 27.12.7 → 27.13.0

package/changelog.md

@@ -1,17 +1,22 @@
 # Changelog
 
-## Pending
-
-
-
-
-
-
+## 2026-06-05 - 27.13.0
 
+### Features
 
+- add route challenge enforcement (challenge)
+  - Add smartchallenge provider registration and relay wiring between TypeScript and the Rust proxy runtime
+  - Enforce route-level browser challenges with pending and clearance cookies plus reserved verification endpoints
+  - Document challenge configuration and add integration tests for protected routes
 
+## 2026-06-05 - 27.12.8
 
+### BREAKING CHANGES
 
+- require explicit inbound PROXY protocol listener policies (proxy-protocol)
+  - Replace global inbound `proxyIPs`/`acceptProxyProtocol` config with exact `trustedProxyIPs` trust lists and listener-scoped `match.inboundProxyProtocol` policies.
+  - Default listeners now reject inbound PROXY protocol unless `mode: 'optional'` or `mode: 'required'` is declared.
+  - Apply explicit inbound policy resolution, validation, and TCP/UDP/QUIC handling while keeping outbound `sendProxyProtocol` separate.
 
 ## 2026-06-04 - 27.12.7
 

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '27.12.7',
+    version: '27.13.0',
     description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFNBQVM7SUFDbEIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -3,7 +3,7 @@
  */
 export { SmartProxy } from './proxies/smart-proxy/index.js';
 export { SharedRouteManager as RouteManager } from './core/routing/route-manager.js';
-export type { ISmartProxyOptions, ISmartProxySecurityPolicy, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteTls, IRouteContext, TDatagramHandler, IDatagramInfo, IActiveConnectionSnapshot, IActiveConnectionSnapshotOptions } from './proxies/smart-proxy/models/index.js';
+export type { ISmartProxyOptions, ISmartProxySecurityPolicy, ISmartProxyChallengeOptions, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteTls, IRouteContext, TDatagramHandler, IDatagramInfo, IActiveConnectionSnapshot, IActiveConnectionSnapshotOptions } from './proxies/smart-proxy/models/index.js';
 export type { TSmartProxyCertProvisionObject, ICertProvisionEventComms, ICertificateIssuedEvent, ICertificateFailedEvent } from './proxies/smart-proxy/models/interfaces.js';
 export * from './proxies/smart-proxy/utils/index.js';
 export * from './core/models/common-types.js';

package/dist_ts/plugins.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'node:events';
+import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import * as http from 'node:http';
 import * as net from 'node:net';
@@ -6,14 +7,15 @@ import * as path from 'node:path';
 import * as tls from 'node:tls';
 import * as url from 'node:url';
 import * as http2 from 'node:http2';
-export { EventEmitter, fs, http, net, path, tls, url, http2 };
+export { EventEmitter, crypto, fs, http, net, path, tls, url, http2 };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
 import * as smartcrypto from '@push.rocks/smartcrypto';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
+import * as smartchallenge from '@push.rocks/smartchallenge';
 import * as smartnftables from '@push.rocks/smartnftables';
 import * as smartrust from '@push.rocks/smartrust';
-export { smartcrypto, smartlog, smartlogDestinationLocal, smartnftables, smartrust, };
+export { smartcrypto, smartchallenge, smartlog, smartlogDestinationLocal, smartnftables, smartrust, };
 import { minimatch } from 'minimatch';
 export { minimatch };

package/dist_ts/plugins.js

@@ -1,5 +1,6 @@
 // node native scope
 import { EventEmitter } from 'node:events';
+import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import * as http from 'node:http';
 import * as net from 'node:net';
@@ -7,7 +8,7 @@ import * as path from 'node:path';
 import * as tls from 'node:tls';
 import * as url from 'node:url';
 import * as http2 from 'node:http2';
-export { EventEmitter, fs, http, net, path, tls, url, http2 };
+export { EventEmitter, crypto, fs, http, net, path, tls, url, http2 };
 // tsclass scope
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
@@ -15,10 +16,11 @@ export { tsclass };
 import * as smartcrypto from '@push.rocks/smartcrypto';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
+import * as smartchallenge from '@push.rocks/smartchallenge';
 import * as smartnftables from '@push.rocks/smartnftables';
 import * as smartrust from '@push.rocks/smartrust';
-export { smartcrypto, smartlog, smartlogDestinationLocal, smartnftables, smartrust, };
+export { smartcrypto, smartchallenge, smartlog, smartlogDestinationLocal, smartnftables, smartrust, };
 // third party scope
 import { minimatch } from 'minimatch';
 export { minimatch };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDM0MsT0FBTyxLQUFLLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDOUIsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLEtBQUssTUFBTSxZQUFZLENBQUM7QUFFcEMsT0FBTyxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsQ0FBQztBQUU5RCxnQkFBZ0I7QUFDaEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssd0JBQXdCLE1BQU0sd0NBQXdDLENBQUM7QUFDbkYsT0FBTyxLQUFLLGFBQWEsTUFBTSwyQkFBMkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFDTCxXQUFXLEVBQ1gsUUFBUSxFQUNSLHdCQUF3QixFQUN4QixhQUFhLEVBQ2IsU0FBUyxHQUNWLENBQUM7QUFFRixvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUV0QyxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDM0MsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDOUIsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLEtBQUssTUFBTSxZQUFZLENBQUM7QUFFcEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLENBQUM7QUFFdEUsZ0JBQWdCO0FBQ2hCLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBRW5CLGtCQUFrQjtBQUNsQixPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLHdCQUF3QixNQUFNLHdDQUF3QyxDQUFDO0FBQ25GLE9BQU8sS0FBSyxjQUFjLE1BQU0sNEJBQTRCLENBQUM7QUFDN0QsT0FBTyxLQUFLLGFBQWEsTUFBTSwyQkFBMkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFDTCxXQUFXLEVBQ1gsY0FBYyxFQUNkLFFBQVEsRUFDUix3QkFBd0IsRUFDeEIsYUFBYSxFQUNiLFNBQVMsR0FDVixDQUFDO0FBRUYsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFdEMsT0FBTyxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=

package/dist_ts/proxies/smart-proxy/challenge-provider-relay-server.d.ts

@@ -0,0 +1,31 @@
+import * as plugins from '../../plugins.js';
+export interface IChallengeProviderRelayServerOptions {
+    providerTimeoutMs?: number;
+    maxActiveProviderOperations?: number;
+    maxUnsettledProviderOperations?: number;
+}
+export declare class ChallengeProviderRelayServer {
+    private providers;
+    private providerTimeoutMs;
+    private maxActiveProviderOperations;
+    private maxUnsettledProviderOperations;
+    private activeProviderOperations;
+    private unsettledProviderOperations;
+    private server;
+    private socketPath;
+    private activeSockets;
+    private startPromise?;
+    constructor(providers: Map<string, plugins.smartchallenge.IChallengeProvider>, optionsArg?: IChallengeProviderRelayServerOptions);
+    getSocketPath(): string;
+    start(): Promise<void>;
+    private startInternal;
+    stop(): Promise<void>;
+    private handleConnection;
+    private dispatchLine;
+    private withProviderTimeout;
+    private writeResponse;
+    private createErrorResponse;
+    private estimateJsonByteLength;
+    private estimateJsonByteLengthInternal;
+    private estimateJsonStringByteLength;
+}

package/dist_ts/proxies/smart-proxy/challenge-provider-relay-server.js

@@ -0,0 +1,297 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../core/utils/logger.js';
+const maxChallengeRelayMessageBytes = 1024 * 1024;
+const maxChallengeRelayIdBytes = 256;
+export class ChallengeProviderRelayServer {
+    providers;
+    providerTimeoutMs;
+    maxActiveProviderOperations;
+    maxUnsettledProviderOperations;
+    activeProviderOperations = 0;
+    unsettledProviderOperations = 0;
+    server = null;
+    socketPath;
+    activeSockets = new Set();
+    startPromise;
+    constructor(providers, optionsArg = {}) {
+        this.providers = providers;
+        this.socketPath = `/tmp/smartproxy-challenge-relay-${process.pid}-${plugins.crypto.randomBytes(8).toString('hex')}.sock`;
+        this.providerTimeoutMs = Math.max(1, optionsArg.providerTimeoutMs ?? 5_000);
+        this.maxActiveProviderOperations = Math.max(1, optionsArg.maxActiveProviderOperations ?? 1024);
+        this.maxUnsettledProviderOperations = Math.max(1, optionsArg.maxUnsettledProviderOperations ?? this.maxActiveProviderOperations);
+    }
+    getSocketPath() {
+        return this.socketPath;
+    }
+    async start() {
+        if (this.server)
+            return;
+        if (this.startPromise)
+            return this.startPromise;
+        this.startPromise = this.startInternal();
+        try {
+            await this.startPromise;
+        }
+        finally {
+            this.startPromise = undefined;
+        }
+    }
+    async startInternal() {
+        try {
+            await plugins.fs.promises.unlink(this.socketPath);
+        }
+        catch {
+            // Ignore stale socket cleanup failures for missing files.
+        }
+        const server = plugins.net.createServer((socket) => {
+            this.activeSockets.add(socket);
+            socket.once('close', () => this.activeSockets.delete(socket));
+            this.handleConnection(socket);
+        });
+        server.on('error', (err) => {
+            logger.log('error', `ChallengeProviderRelayServer error: ${err.message}`, { component: 'challenge-provider-relay-server' });
+        });
+        await new Promise((resolve, reject) => {
+            const handleError = (err) => reject(err);
+            server.once('error', handleError);
+            server.listen(this.socketPath, () => {
+                server.off('error', handleError);
+                this.server = server;
+                logger.log('info', `ChallengeProviderRelayServer listening on ${this.socketPath}`, { component: 'challenge-provider-relay-server' });
+                resolve();
+            });
+        }).catch((err) => {
+            server.close();
+            throw err;
+        });
+    }
+    async stop() {
+        if (this.startPromise && !this.server) {
+            await this.startPromise.catch(() => undefined);
+        }
+        for (const socket of this.activeSockets) {
+            socket.destroy();
+        }
+        this.activeSockets.clear();
+        const server = this.server;
+        if (!server)
+            return;
+        this.server = null;
+        await new Promise((resolve) => {
+            server.close(() => {
+                plugins.fs.unlink(this.socketPath, () => resolve());
+            });
+        });
+    }
+    handleConnection(socket) {
+        let buffer = Buffer.alloc(0);
+        socket.setTimeout(Math.max(10_000, this.providerTimeoutMs + 1_000));
+        socket.on('timeout', () => socket.destroy());
+        socket.on('error', (err) => {
+            logger.log('warn', `Challenge relay socket error: ${err.message}`, { component: 'challenge-provider-relay-server' });
+        });
+        socket.on('data', (chunk) => {
+            buffer = buffer.length === 0 ? chunk : Buffer.concat([buffer, chunk], buffer.length + chunk.length);
+            if (buffer.length > maxChallengeRelayMessageBytes) {
+                socket.removeAllListeners('data');
+                this.writeResponse(socket, { success: false, error: 'Challenge relay request exceeds maximum size' });
+                buffer = Buffer.alloc(0);
+                socket.end();
+                return;
+            }
+            const newlineIndex = buffer.indexOf(0x0a);
+            if (newlineIndex === -1)
+                return;
+            const line = buffer.subarray(0, newlineIndex).toString('utf8');
+            socket.removeAllListeners('data');
+            this.dispatchLine(line)
+                .then((response) => this.writeResponse(socket, response))
+                .catch((err) => this.writeResponse(socket, { success: false, error: err.message }))
+                .finally(() => socket.end());
+        });
+    }
+    async dispatchLine(lineArg) {
+        let request;
+        try {
+            request = JSON.parse(lineArg);
+        }
+        catch {
+            return { success: false, error: 'Invalid challenge relay JSON' };
+        }
+        const provider = this.providers.get(request.providerId);
+        if (!provider) {
+            return {
+                id: request.id,
+                success: false,
+                error: `Challenge provider '${request.providerId}' is not registered`,
+            };
+        }
+        switch (request.operation) {
+            case 'assess':
+                return { id: request.id, success: true, result: await this.withProviderTimeout(() => provider.assess(request.request), 'assess') };
+            case 'render':
+                return { id: request.id, success: true, result: await this.withProviderTimeout(() => provider.render(request.request), 'render') };
+            case 'verify':
+                return { id: request.id, success: true, result: await this.withProviderTimeout(() => provider.verify(request.request), 'verify') };
+            default:
+                const operationValue = request.operation;
+                return { id: request.id, success: false, error: `Unsupported challenge relay operation '${String(operationValue)}'` };
+        }
+    }
+    async withProviderTimeout(operationArg, operationNameArg) {
+        if (this.activeProviderOperations >= this.maxActiveProviderOperations) {
+            throw new Error(`Challenge provider ${operationNameArg} rejected because too many operations are active`);
+        }
+        if (this.unsettledProviderOperations >= this.maxUnsettledProviderOperations) {
+            throw new Error(`Challenge provider ${operationNameArg} rejected because too many timed-out operations are still settling`);
+        }
+        let timer;
+        let activeReleased = false;
+        let unsettledReleased = false;
+        const releaseActive = () => {
+            if (!activeReleased) {
+                activeReleased = true;
+                this.activeProviderOperations -= 1;
+            }
+        };
+        const releaseUnsettled = () => {
+            if (!unsettledReleased) {
+                unsettledReleased = true;
+                this.unsettledProviderOperations -= 1;
+            }
+        };
+        this.activeProviderOperations += 1;
+        this.unsettledProviderOperations += 1;
+        const providerPromise = Promise.resolve().then(operationArg);
+        const trackedProviderPromise = providerPromise.then((result) => {
+            releaseActive();
+            releaseUnsettled();
+            return result;
+        }, (err) => {
+            releaseActive();
+            releaseUnsettled();
+            throw err;
+        });
+        trackedProviderPromise.catch(() => undefined);
+        try {
+            return await Promise.race([
+                trackedProviderPromise,
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => {
+                        releaseActive();
+                        reject(new Error(`Challenge provider ${operationNameArg} timed out after ${this.providerTimeoutMs}ms`));
+                    }, this.providerTimeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    writeResponse(socket, responseArg) {
+        let response = responseArg;
+        if (this.estimateJsonByteLength(response, maxChallengeRelayMessageBytes) === undefined) {
+            response = this.createErrorResponse(responseArg.id, 'Challenge relay response exceeds maximum size');
+        }
+        let serializedResponse;
+        try {
+            serializedResponse = JSON.stringify(response);
+        }
+        catch {
+            serializedResponse = JSON.stringify(this.createErrorResponse(responseArg.id, 'Challenge relay response is not serializable'));
+        }
+        if (Buffer.byteLength(serializedResponse, 'utf8') > maxChallengeRelayMessageBytes) {
+            serializedResponse = JSON.stringify({
+                success: false,
+                error: 'Challenge relay response exceeds maximum size',
+            });
+        }
+        socket.write(`${serializedResponse}\n`);
+    }
+    createErrorResponse(idArg, errorArg) {
+        const response = {
+            success: false,
+            error: errorArg,
+        };
+        if (idArg && Buffer.byteLength(idArg, 'utf8') <= maxChallengeRelayIdBytes) {
+            response.id = idArg;
+        }
+        return response;
+    }
+    estimateJsonByteLength(valueArg, maxBytesArg, seenArg = new Set()) {
+        const bytes = this.estimateJsonByteLengthInternal(valueArg, maxBytesArg, seenArg);
+        return bytes !== undefined && bytes <= maxBytesArg ? bytes : undefined;
+    }
+    estimateJsonByteLengthInternal(valueArg, maxBytesArg, seenArg) {
+        if (valueArg === null)
+            return 4;
+        if (typeof valueArg === 'string')
+            return this.estimateJsonStringByteLength(valueArg, maxBytesArg);
+        if (typeof valueArg === 'number')
+            return Number.isFinite(valueArg) ? String(valueArg).length : 4;
+        if (typeof valueArg === 'boolean')
+            return valueArg ? 4 : 5;
+        if (typeof valueArg === 'undefined')
+            return 4;
+        if (typeof valueArg === 'bigint' || typeof valueArg === 'symbol' || typeof valueArg === 'function')
+            return undefined;
+        if (typeof valueArg !== 'object')
+            return undefined;
+        if (seenArg.has(valueArg))
+            return undefined;
+        seenArg.add(valueArg);
+        try {
+            let totalBytes = 2;
+            if (Array.isArray(valueArg)) {
+                for (let i = 0; i < valueArg.length; i++) {
+                    const childBytes = this.estimateJsonByteLengthInternal(valueArg[i], maxBytesArg, seenArg);
+                    if (childBytes === undefined)
+                        return undefined;
+                    totalBytes += childBytes + (i > 0 ? 1 : 0);
+                    if (totalBytes > maxBytesArg)
+                        return undefined;
+                }
+                return totalBytes;
+            }
+            let propertyCount = 0;
+            for (const [key, value] of Object.entries(valueArg)) {
+                if (typeof value === 'undefined' || typeof value === 'function' || typeof value === 'symbol')
+                    continue;
+                const keyBytes = this.estimateJsonStringByteLength(key, maxBytesArg);
+                const valueBytes = this.estimateJsonByteLengthInternal(value, maxBytesArg, seenArg);
+                if (keyBytes === undefined || valueBytes === undefined)
+                    return undefined;
+                totalBytes += keyBytes + valueBytes + 1 + (propertyCount > 0 ? 1 : 0);
+                propertyCount += 1;
+                if (totalBytes > maxBytesArg)
+                    return undefined;
+            }
+            return totalBytes;
+        }
+        finally {
+            seenArg.delete(valueArg);
+        }
+    }
+    estimateJsonStringByteLength(valueArg, maxBytesArg) {
+        let bytes = Buffer.byteLength(valueArg, 'utf8') + 2;
+        if (bytes > maxBytesArg)
+            return undefined;
+        for (let i = 0; i < valueArg.length; i++) {
+            const code = valueArg.charCodeAt(i);
+            if (code === 0x22 || code === 0x5c) {
+                bytes += 1;
+            }
+            else if (code === 0x08 || code === 0x09 || code === 0x0a || code === 0x0c || code === 0x0d) {
+                bytes += 1;
+            }
+            else if (code < 0x20) {
+                bytes += 5;
+            }
+            if (bytes > maxBytesArg)
+                return undefined;
+        }
+        return bytes;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"challenge-provider-relay-server.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/challenge-provider-relay-server.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/models/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * SmartProxy models
  */
-export type { ISmartProxyOptions, ISmartProxySecurityPolicy, ISmartProxyCertStore, IConnectionRecord, TSmartProxyCertProvisionObject, ICertProvisionEventComms, ICertificateIssuedEvent, ICertificateFailedEvent, IActiveConnectionSnapshot, IActiveConnectionSnapshotOptions } from './interfaces.js';
+export type { ISmartProxyOptions, ISmartProxySecurityPolicy, ISmartProxyChallengeOptions, ISmartProxyCertStore, IConnectionRecord, TChallengeProviderRegistry, TSmartProxyCertProvisionObject, ICertProvisionEventComms, ICertificateIssuedEvent, ICertificateFailedEvent, IActiveConnectionSnapshot, IActiveConnectionSnapshotOptions } from './interfaces.js';
 export * from './route-types.js';
 export * from './metrics-types.js';

package/dist_ts/proxies/smart-proxy/models/interfaces.d.ts

@@ -35,6 +35,16 @@ export interface ISmartProxySecurityPolicy {
     blockedIps?: string[];
     blockedCidrs?: string[];
 }
+export interface ISmartProxyChallengeOptions {
+    /** Runtime-only cookie signing key. If omitted, SmartProxy generates an ephemeral key. */
+    cookieSigningKey?: string;
+    pendingCookieName?: string;
+    clearanceCookieName?: string;
+    reservedPathPrefix?: string;
+    relaySocketPath?: string;
+    relayTimeoutMs?: number;
+    pendingTtlSeconds?: number;
+}
 /**
  * Provision object for static or HTTP-01 certificate
  */
@@ -99,8 +109,7 @@ export interface IActiveConnectionSnapshot {
 export interface ISmartProxyOptions {
     routes: IRouteConfig[];
     preserveSourceIP?: boolean;
-    proxyIPs?: string[];
-    acceptProxyProtocol?: boolean;
+    trustedProxyIPs?: string[];
     sendProxyProtocol?: boolean;
     defaults?: {
         target?: {
@@ -145,6 +154,8 @@ export interface ISmartProxyOptions {
     maxConnectionsPerIP?: number;
     connectionRateLimitPerMinute?: number;
     securityPolicy?: ISmartProxySecurityPolicy;
+    /** Runtime-only challenge enforcement settings. Never store this in route configs. */
+    challenge?: ISmartProxyChallengeOptions;
     keepAliveTreatment?: 'standard' | 'extended' | 'immortal';
     keepAliveInactivityMultiplier?: number;
     extendedKeepAliveLifetime?: number;
@@ -211,6 +222,7 @@ export interface ISmartProxyOptions {
      */
     rustBinaryPath?: string;
 }
+export type TChallengeProviderRegistry = Map<string, plugins.smartchallenge.IChallengeProvider>;
 /**
  * Enhanced connection record
  */

package/dist_ts/proxies/smart-proxy/models/route-types.d.ts

@@ -17,6 +17,14 @@ export type TTlsMode = 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
  * Transport protocol for route matching
  */
 export type TTransportProtocol = 'tcp' | 'udp' | 'all';
+/**
+ * Inbound PROXY protocol handling for a listener.
+ */
+export type TInboundProxyProtocolMode = 'reject' | 'optional' | 'required';
+export interface IInboundProxyProtocolPolicy {
+    mode: TInboundProxyProtocolMode;
+    trustedProxyIPs?: string[];
+}
 /**
  * Port range specification format.
  * Supports: single number, array of numbers, array of ranges, or mixed arrays.
@@ -31,6 +39,7 @@ export type TPortRange = number | Array<number | {
 export interface IRouteMatch {
     ports: TPortRange;
     transport?: TTransportProtocol;
+    inboundProxyProtocol?: IInboundProxyProtocolPolicy;
     domains?: string | string[];
     path?: string;
     clientIp?: string[];
@@ -149,6 +158,8 @@ export interface IRouteSecurity {
         /** Allowed VPN tunnel IPs, kept for compatibility. Prefer allowedClients. */
         allowedAssignedIps?: string[];
     };
+    /** Browser-facing challenge policy. SmartProxy enforces this in the HTTP path. */
+    challenge?: plugins.smartchallenge.IRouteChallengeConfig;
 }
 /**
  * Static file server configuration

package/dist_ts/proxies/smart-proxy/models/route-types.js

@@ -1,3 +1,3 @@
 import * as plugins from '../../../plugins.js';
 // Configuration moved to models/interfaces.ts as ISmartProxyOptions
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9yb3V0ZS10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBK2IvQyxvRUFBb0UifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9yb3V0ZS10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBZ2QvQyxvRUFBb0UifQ==

package/dist_ts/proxies/smart-proxy/models/rust-types.d.ts

@@ -1,5 +1,5 @@
 import type { IProtocolCacheEntry, IProtocolDistribution } from './metrics-types.js';
-import type { IAcmeOptions, ISmartProxyOptions, ISmartProxySecurityPolicy } from './interfaces.js';
+import type { IAcmeOptions, ISmartProxyChallengeOptions, ISmartProxyOptions, ISmartProxySecurityPolicy } from './interfaces.js';
 import type { IRouteAction, IRouteConfig, IRouteMatch, IRouteTarget, ITargetMatch, IRouteUdp } from './route-types.js';
 export type TRustHeaderMatchers = Record<string, string>;
 export interface IRustRouteMatch extends Omit<IRouteMatch, 'headers'> {
@@ -29,11 +29,12 @@ export interface IRustRouteConfig extends Omit<IRouteConfig, 'match' | 'action'>
 }
 export interface IRustAcmeOptions extends Omit<IAcmeOptions, 'routeForwards'> {
 }
+export interface IRustChallengeOptions extends Required<Pick<ISmartProxyChallengeOptions, 'cookieSigningKey' | 'pendingCookieName' | 'clearanceCookieName' | 'reservedPathPrefix' | 'relaySocketPath' | 'relayTimeoutMs' | 'pendingTtlSeconds'>> {
+}
 export interface IRustProxyOptions {
     routes: IRustRouteConfig[];
     preserveSourceIp?: boolean;
-    proxyIps?: string[];
-    acceptProxyProtocol?: boolean;
+    trustedProxyIPs?: string[];
     sendProxyProtocol?: boolean;
     defaults?: IRustDefaultConfig;
     connectionTimeout?: number;
@@ -59,6 +60,7 @@ export interface IRustProxyOptions {
     extendedKeepAliveLifetime?: number;
     metrics?: ISmartProxyOptions['metrics'];
     securityPolicy?: ISmartProxySecurityPolicy;
+    challenge?: IRustChallengeOptions;
     acme?: IRustAcmeOptions;
 }
 export interface IRustStatistics {

package/dist_ts/proxies/smart-proxy/rust-proxy-bridge.d.ts

@@ -1,5 +1,5 @@
 import * as plugins from '../../plugins.js';
-import type { IRustCertificateStatus, IRustMetricsSnapshot, IRustProxyOptions, IRustRouteConfig, IRustStatistics } from './models/rust-types.js';
+import type { IRustCertificateStatus, IRustChallengeOptions, IRustMetricsSnapshot, IRustProxyOptions, IRustRouteConfig, IRustStatistics } from './models/rust-types.js';
 import type { IActiveConnectionSnapshot, IActiveConnectionSnapshotOptions, ISmartProxySecurityPolicy } from './models/interfaces.js';
 /**
  * Bridge between TypeScript SmartProxy and the Rust binary.
@@ -33,6 +33,7 @@ export declare class RustProxyBridge extends plugins.EventEmitter {
     getCertificateStatus(routeName: string): Promise<IRustCertificateStatus | null>;
     getListeningPorts(): Promise<number[]>;
     setSocketHandlerRelay(socketPath: string): Promise<void>;
+    setChallengeProviderRelay(socketPath: string, options?: IRustChallengeOptions): Promise<void>;
     addListeningPort(port: number): Promise<void>;
     removeListeningPort(port: number): Promise<void>;
     loadCertificate(domain: string, cert: string, key: string, ca?: string): Promise<void>;