@awiki/dsh-pap 0.0.0-stage → 0.1.0

package/lib/file-secrets.js

@@ -0,0 +1,148 @@
+import { randomBytes, createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { chmod, lstat, mkdir, open, link, rm } from 'node:fs/promises';
+import { isAbsolute, join, resolve, relative, sep } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { PapError, requirePap } from './errors.js';
+const execute = promisify(execFile);
+/** Protect only this user's directory/file; Windows uses DACLs rather than chmod. */
+async function protect(path, directory) {
+    const info = await lstat(path);
+    requirePap(!info.isSymbolicLink() && (directory ? info.isDirectory() : info.isFile()), 'credential_unavailable');
+    if (process.platform !== 'win32') {
+        requirePap(typeof process.getuid === 'function' && info.uid === process.getuid(), 'credential_unavailable');
+        await chmod(path, directory ? 0o700 : 0o600);
+        return;
+    }
+    // Paths travel in the child environment, never as executable PowerShell text.
+    const script = `
+$ErrorActionPreference = 'Stop'
+$p = $env:DSH_PAP_PROTECT_PATH
+$sid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
+$old = Get-Acl -LiteralPath $p
+if ($old.GetOwner([System.Security.Principal.SecurityIdentifier]).Value -ne $sid.Value) { throw 'Unexpected owner' }
+if ($env:DSH_PAP_PROTECT_DIRECTORY -eq '1') {
+  $acl = New-Object System.Security.AccessControl.DirectorySecurity
+  $rule = New-Object System.Security.AccessControl.FileSystemAccessRule($sid, 'FullControl', 'ContainerInherit,ObjectInherit', 'None', 'Allow')
+} else {
+  $acl = New-Object System.Security.AccessControl.FileSecurity
+  $rule = New-Object System.Security.AccessControl.FileSystemAccessRule($sid, 'FullControl', 'Allow')
+}
+$acl.SetOwner($sid)
+$acl.SetAccessRuleProtection($true, $false)
+$acl.AddAccessRule($rule)
+Set-Acl -LiteralPath $p -AclObject $acl
+`;
+    await execute('powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')], {
+        env: { ...process.env, DSH_PAP_PROTECT_PATH: path, DSH_PAP_PROTECT_DIRECTORY: directory ? '1' : '0' },
+        timeout: 10000, windowsHide: true, maxBuffer: 4096,
+    });
+}
+/** Flush directories where the OS supports opening them; Windows still flushes files. */
+export async function syncDirectory(path) {
+    if (process.platform === 'win32')
+        return;
+    const directory = await open(path, 'r');
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}
+/** File-backed PAP state encryption keys. Identity/signing keys remain in native custody. */
+export class FileSecretStore {
+    root;
+    constructor(root) {
+        requirePap(isAbsolute(root), 'credential_unavailable');
+        this.root = resolve(root);
+    }
+    assertSeparateFrom(stateRoot) {
+        const inside = (parent, child) => {
+            const path = relative(resolve(parent), resolve(child));
+            return path === '' || (path !== '..' && !path.startsWith('..' + sep) && !isAbsolute(path));
+        };
+        requirePap(!inside(stateRoot, this.root) && !inside(this.root, stateRoot), 'credential_unavailable');
+    }
+    path(namespace) {
+        requirePap(typeof namespace === 'string' && namespace.length > 0, 'credential_unavailable');
+        return join(this.root, createHash('sha256').update(namespace).digest('hex') + '.key');
+    }
+    async prepare() {
+        await mkdir(this.root, { recursive: true, mode: 0o700 });
+        await protect(this.root, true);
+    }
+    async read(path) {
+        try {
+            await protect(path, false);
+            const file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+            try {
+                const info = await file.stat();
+                requirePap(info.isFile() && info.size === 32, 'credential_unavailable');
+                const value = await file.readFile();
+                requirePap(value.length === 32, 'credential_unavailable');
+                return value;
+            }
+            finally {
+                await file.close();
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw new PapError('credential_unavailable');
+        }
+    }
+    async getEncryptionKey(namespace) {
+        try {
+            await this.prepare();
+            return await this.read(this.path(namespace));
+        }
+        catch {
+            throw new PapError('credential_unavailable');
+        }
+    }
+    async getOrCreateEncryptionKey(namespace) {
+        let temporary;
+        let material;
+        try {
+            await this.prepare();
+            const path = this.path(namespace);
+            const existing = await this.read(path);
+            if (existing)
+                return existing;
+            temporary = join(this.root, '.' + randomBytes(16).toString('hex') + '.tmp');
+            const file = await open(temporary, 'wx', 0o600);
+            try {
+                await protect(temporary, false);
+                material = randomBytes(32);
+                await file.writeFile(material);
+                await file.sync();
+            }
+            finally {
+                await file.close();
+            }
+            // A hard link publishes a fully written key atomically without replacing a winner.
+            try {
+                await link(temporary, path);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+            await syncDirectory(this.root);
+            const result = await this.read(path);
+            requirePap(result, 'credential_unavailable');
+            return result;
+        }
+        catch {
+            throw new PapError('credential_unavailable');
+        }
+        finally {
+            material?.fill(0);
+            if (temporary)
+                await rm(temporary, { force: true }).catch(() => { throw new PapError('credential_unavailable'); });
+        }
+    }
+}

package/lib/host-secrets.d.ts

@@ -0,0 +1,16 @@
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { HostSecretStore } from './host.js';
+import type { PapHostServices } from './plugin.js';
+export interface Config {
+    secretStore?: 'keyring' | 'local-file';
+    secretsRoot?: string;
+    keyringService?: string;
+    locksRoot?: string;
+}
+export declare const name = "@awiki/dsh-pap/host-secrets";
+/** Optional Host secrets provider with an explicitly selected storage backend. */
+export declare class PapHostService extends Service implements PapHostServices {
+    readonly secrets: HostSecretStore;
+    constructor(ctx: Context, config: Config);
+}
+export declare function apply(ctx: Context, config: Config): PapHostService;

package/lib/host-secrets.js

@@ -0,0 +1,22 @@
+import { Service } from '@deepseek-ai/cordis';
+import { KeyringSecretStore } from './keyring.js';
+import { FileSecretStore } from './file-secrets.js';
+import { requirePap } from './errors.js';
+export const name = '@awiki/dsh-pap/host-secrets';
+/** Optional Host secrets provider with an explicitly selected storage backend. */
+export class PapHostService extends Service {
+    secrets;
+    constructor(ctx, config) {
+        super(ctx, 'papHost');
+        requirePap(config.secretStore === undefined || ['keyring', 'local-file'].includes(config.secretStore), 'not_configured');
+        if (config.secretStore === 'local-file') {
+            requirePap(typeof config.secretsRoot === 'string', 'not_configured');
+            this.secrets = new FileSecretStore(config.secretsRoot);
+        }
+        else {
+            requirePap(typeof config.keyringService === 'string' && typeof config.locksRoot === 'string', 'not_configured');
+            this.secrets = new KeyringSecretStore(config.keyringService, config.locksRoot);
+        }
+    }
+}
+export function apply(ctx, config) { return new PapHostService(ctx, config); }

package/lib/host.d.ts

@@ -0,0 +1,83 @@
+import type { AsMetadata, Binding, Company, IdentityRef, KeyRef, KeyScope, PublicJwk } from './types.js';
+import type { CredentialObservation } from './credential-history.js';
+/** Same-process Host capability. Never expose through Remote or tools. */
+export interface PapSigningLease {
+    /** Actual C target object, Host-only; never serialized or accepted from user input. */
+    readonly targetRef?: object;
+    getOAuthClientIdentity(): Promise<{
+        clientId: string;
+        alg: string;
+        kid: string;
+        publicJwk?: PublicJwk;
+        redirectUris?: string[];
+    }>;
+    createDelegatedKey(scope: KeyScope, operationId: string): Promise<KeyRef>;
+    issuePapDelegation(key: KeyRef, scope: KeyScope, ttlSeconds: number): Promise<string>;
+    signPapSessionRequest(input: {
+        key: KeyRef;
+        scope: KeyScope;
+        delegation: string;
+        clientId: string;
+        sid: string;
+        sub: string;
+        agentId?: string;
+        httpMethod: string;
+        httpUri: string;
+        accessToken?: string;
+    }): Promise<string>;
+    createDpopKey(scope: KeyScope, operationId: string): Promise<KeyRef>;
+    signDpopProof(input: {
+        key: KeyRef;
+        scope: KeyScope;
+        httpMethod: string;
+        httpUri: string;
+        accessToken?: string;
+        nonce?: string;
+    }): Promise<string>;
+    signOAuthClientAssertion(): Promise<string>;
+    retireTemporaryKey(key: KeyRef, scope: KeyScope): Promise<void>;
+    assertActive(): Promise<void>;
+}
+export interface PapIdentityHost {
+    dispose?(): void;
+    /** Host must independently verify sources and enforce preapproved target policy. */
+    acquire(binding: Binding, company: Company, purpose: 'pap_session' | 'pap_account', resource: string, destination?: string, requestedScopes?: readonly string[]): Promise<PapSigningLease>;
+}
+export interface HostSecretStore {
+    getEncryptionKey(namespace: string): Promise<Uint8Array | undefined>;
+    /** Atomic across Host processes; key is 32 random bytes and never persisted in the PAP directory. */
+    getOrCreateEncryptionKey(namespace: string): Promise<Uint8Array>;
+}
+export interface CallbackHandoff {
+    /** Authenticated device-bound registration; the service receives no PKCE verifier or PAP IDs. */
+    register(input: {
+        transactionId: string;
+        issuer: string;
+        clientId: string;
+        redirectUri: string;
+        state: string;
+        expiresAt: number;
+    }): Promise<{
+        callbackRef: string;
+    }>;
+    collect(callbackRef: string): Promise<{
+        state?: string;
+        iss?: string;
+        code?: string;
+        error?: string;
+    }>;
+    cancel?(callbackRef: string): Promise<void>;
+}
+export interface PapHostOptions {
+    binding: Binding;
+    identityHost: PapIdentityHost;
+    secretStore: HostSecretStore;
+    stateRoot: string;
+    callbackHandoff?: CallbackHandoff;
+    clock?: () => number;
+    /** Maximum local inline cooldown wait, 0..5000ms; this never shortens the persisted server fence. */
+    inlineCooldownWaitMs?: number;
+    /** Host-only observer, must not throw or log; used for private response-redaction history. */
+    observeCredentials?: (credentials: CredentialObservation) => void;
+}
+export type { AsMetadata, IdentityRef };

package/lib/host.js

@@ -0,0 +1 @@
+export {};

package/lib/index.d.ts

@@ -0,0 +1,21 @@
+export { PapClient } from './client.js';
+export { PapError } from './errors.js';
+export type { PapErrorCode, PapAuthHint } from './errors.js';
+export { PapDiscovery } from './discovery.js';
+export { SafeHttpsTransport } from './network.js';
+export type { SafeHttpsOptions } from './network.js';
+export { ProtocolIdentityHost } from './protocol-adapter.js';
+export type { ProtocolIdentityClient } from './protocol-adapter.js';
+export type { Binding, Company, Operation, HttpTransport, HttpResponse } from './types.js';
+export type { HostSecretStore, CallbackHandoff, PapIdentityHost, PapSigningLease, PapHostOptions } from './host.js';
+export { DeviceCallbackHandoff } from './callback-handoff.js';
+export type { DeviceManagementOperations, CallbackManagementOperation, CallbackRegistration, CallbackClaim, CallbackRegistrationResult, CallbackClaimResult, RegisterCallbackOperation, ClaimCallbackOperation } from './callback-handoff.js';
+export { PapService } from './plugin.js';
+export type { PapPluginConfig, PapHostServices } from './plugin.js';
+export type { PapHostConsumer, PapManagementRequest, PapOperationRequest, ProductResult } from './product-api.js';
+export { FileSecretStore } from './file-secrets.js';
+export { KeyringSecretStore } from './keyring.js';
+/** Root Loader row declares the browser client; the capability-owning service is ./plugin. */
+export declare const name = "@awiki/dsh-pap";
+export declare const inject: string[];
+export declare function apply(_context: import('@deepseek-ai/cordis').Context): void;

package/lib/index.js

@@ -0,0 +1,13 @@
+export { PapClient } from './client.js';
+export { PapError } from './errors.js';
+export { PapDiscovery } from './discovery.js';
+export { SafeHttpsTransport } from './network.js';
+export { ProtocolIdentityHost } from './protocol-adapter.js';
+export { DeviceCallbackHandoff } from './callback-handoff.js';
+export { PapService } from './plugin.js';
+export { FileSecretStore } from './file-secrets.js';
+export { KeyringSecretStore } from './keyring.js';
+/** Root Loader row declares the browser client; the capability-owning service is ./plugin. */
+export const name = '@awiki/dsh-pap';
+export const inject = [];
+export function apply(_context) { }

package/lib/keyring.d.ts

@@ -0,0 +1,10 @@
+import type { HostSecretStore } from './host.js';
+/** Linux Secret Service adapter. No file fallback; a locked/missing keyring blocks credentials. */
+export declare class KeyringSecretStore implements HostSecretStore {
+    private readonly service;
+    private readonly locksRoot;
+    constructor(service: string, locksRoot: string);
+    private command;
+    getEncryptionKey(namespace: string): Promise<Uint8Array | undefined>;
+    getOrCreateEncryptionKey(namespace: string): Promise<Uint8Array>;
+}

package/lib/keyring.js

@@ -0,0 +1,64 @@
+import { spawn } from 'node:child_process';
+import { mkdir } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import lockfile from 'proper-lockfile';
+import { PapError, requirePap } from './errors.js';
+/** Linux Secret Service adapter. No file fallback; a locked/missing keyring blocks credentials. */
+export class KeyringSecretStore {
+    service;
+    locksRoot;
+    constructor(service, locksRoot) {
+        this.service = service;
+        this.locksRoot = locksRoot;
+        requirePap(service.length > 0 && isAbsolute(locksRoot), 'credential_unavailable');
+    }
+    command(args, input) {
+        return new Promise((resolve, reject) => {
+            const child = spawn('secret-tool', args, { stdio: ['pipe', 'pipe', 'ignore'], env: process.env });
+            let value = '';
+            const timeout = setTimeout(() => { child.kill('SIGKILL'); reject(new PapError('credential_unavailable')); }, 5000);
+            child.stdout.on('data', chunk => { value += String(chunk); if (value.length > 256) {
+                child.kill('SIGKILL');
+                clearTimeout(timeout);
+                reject(new PapError('credential_unavailable'));
+            } });
+            child.on('error', () => { clearTimeout(timeout); reject(new PapError('credential_unavailable')); });
+            child.on('close', code => { clearTimeout(timeout); resolve({ code: code ?? -1, value: value.trim() }); });
+            child.stdin.on('error', () => { });
+            child.stdin.end(input === undefined ? undefined : `${input}\n`);
+        });
+    }
+    async getEncryptionKey(namespace) {
+        requirePap(process.platform === 'linux', 'credential_unavailable');
+        const result = await this.command(['lookup', 'service', this.service, 'namespace', namespace]);
+        if (result.code === 1 && result.value === '')
+            return undefined;
+        requirePap(result.code === 0 && /^[A-Za-z0-9_-]{43}$/.test(result.value), 'credential_unavailable');
+        return Buffer.from(result.value, 'base64url');
+    }
+    async getOrCreateEncryptionKey(namespace) {
+        requirePap(process.platform === 'linux', 'credential_unavailable');
+        await mkdir(this.locksRoot, { recursive: true, mode: 0o700 });
+        const release = await lockfile.lock(this.locksRoot, { retries: { retries: 60, minTimeout: 50, maxTimeout: 100 }, stale: 30000 });
+        try {
+            const attributes = ['service', this.service, 'namespace', namespace];
+            const existing = await this.command(['lookup', ...attributes]);
+            if (existing.code === 0) {
+                requirePap(/^[A-Za-z0-9_-]{43}$/.test(existing.value), 'credential_unavailable');
+                return Buffer.from(existing.value, 'base64url');
+            }
+            requirePap(existing.code === 1 && existing.value === '', 'credential_unavailable');
+            const key = randomBytes(32);
+            const encoded = key.toString('base64url');
+            const stored = await this.command(['store', '--label=DSH PAP encrypted state', ...attributes], encoded);
+            requirePap(stored.code === 0, 'credential_unavailable');
+            const checked = await this.command(['lookup', ...attributes]);
+            requirePap(checked.code === 0 && checked.value === encoded, 'credential_unavailable');
+            return key;
+        }
+        finally {
+            await release();
+        }
+    }
+}

package/lib/management-remote.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { PapManagementRequest } from './product-api.js';
+/** Mounted only on the authenticated user management Gateway, never an Agent tool. */
+export default class PapManagerRemote extends TypertRemoteService {
+    static inject: string[];
+    private readonly manager;
+    constructor(ctx: Context);
+    status(): Promise<import("./product-api.js").ProductResult>;
+    operations(): Promise<import("./product-api.js").ProductResult>;
+    /** Browser authorization URL is returned only through this user management endpoint. */
+    manage(input: PapManagementRequest): Promise<import("./product-api.js").ProductResult>;
+}

package/lib/management-remote.js

@@ -0,0 +1,69 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import contribution from './remote.js';
+let PapManagerRemote = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _status_decorators;
+    let _operations_decorators;
+    let _manage_decorators;
+    return class PapManagerRemote extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _status_decorators = [Remote];
+            _operations_decorators = [Remote];
+            _manage_decorators = [Remote];
+            __esDecorate(this, null, _status_decorators, { kind: "method", name: "status", static: false, private: false, access: { has: obj => "status" in obj, get: obj => obj.status }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _operations_decorators, { kind: "method", name: "operations", static: false, private: false, access: { has: obj => "operations" in obj, get: obj => obj.operations }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _manage_decorators, { kind: "method", name: "manage", static: false, private: false, access: { has: obj => "manage" in obj, get: obj => obj.manage }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['pap', 'typert'];
+        manager = __runInitializers(this, _instanceExtraInitializers);
+        constructor(ctx) {
+            super(ctx, 'papManager');
+            this.manager = ctx.pap.acquireManagement(ctx);
+            ctx.effect(() => ctx.typert.register({ package: contribution.package, face: 'host', schemas: [],
+                model: { services: [], events: [], objects: [] }, invocations: contribution.descriptors }));
+        }
+        status() { return this.manager.status(); }
+        operations() { return this.manager.operations(); }
+        /** Browser authorization URL is returned only through this user management endpoint. */
+        manage(input) { return this.manager.execute(input); }
+    };
+})();
+/** Mounted only on the authenticated user management Gateway, never an Agent tool. */
+export default PapManagerRemote;

package/lib/network.d.ts

@@ -0,0 +1,23 @@
+import type { HttpResponse, HttpTransport } from './types.js';
+export declare function isPublicAddress(address: string): boolean;
+export interface SafeHttpsOptions {
+    timeoutMs?: number;
+    maxBytes?: number;
+    maxRequestBytes?: number;
+    maxConcurrent?: number;
+    /** Explicit isolated deployment/test exception; exact origins only. TLS still verified. */
+    privateOrigins?: readonly string[];
+    ca?: string | Buffer;
+    /** Exact-origin mapping for isolated HTTPS component environments; requires privateOrigins. */
+    portOverrides?: Readonly<Record<string, number>>;
+    lookup?: (host: string) => Promise<{
+        address: string;
+        family: number;
+    }[]>;
+}
+export declare class SafeHttpsTransport implements HttpTransport {
+    private readonly options;
+    private active;
+    constructor(options?: SafeHttpsOptions);
+    request(value: string, options?: Parameters<HttpTransport['request']>[1]): Promise<HttpResponse>;
+}

package/lib/network.js

@@ -0,0 +1,91 @@
+import https from 'node:https';
+import { lookup as dnsLookup } from 'node:dns/promises';
+import { BlockList, isIP } from 'node:net';
+import { PapError, requirePap } from './errors.js';
+import { httpsUrl } from './util.js';
+const denied = new BlockList();
+for (const [address, prefix] of [['0.0.0.0', 8], ['10.0.0.0', 8], ['100.64.0.0', 10], ['127.0.0.0', 8], ['169.254.0.0', 16], ['172.16.0.0', 12], ['192.0.0.0', 24], ['192.0.2.0', 24], ['192.168.0.0', 16], ['198.18.0.0', 15], ['198.51.100.0', 24], ['203.0.113.0', 24], ['224.0.0.0', 4], ['240.0.0.0', 4]])
+    denied.addSubnet(address, prefix, 'ipv4');
+const deniedV6 = new BlockList();
+for (const [address, prefix] of [['2001::', 23], ['2001:db8::', 32], ['2002::', 16], ['3fff::', 20]])
+    deniedV6.addSubnet(address, prefix, 'ipv6');
+export function isPublicAddress(address) {
+    if (isIP(address) === 4)
+        return !denied.check(address, 'ipv4');
+    if (isIP(address) !== 6)
+        return false;
+    // Only globally routable unicast IPv6; mapped IPv4 and special ranges are excluded.
+    const first = Number.parseInt(address.split(':')[0], 16);
+    return first >= 0x2000 && first <= 0x3fff && !deniedV6.check(address, 'ipv6');
+}
+export class SafeHttpsTransport {
+    options;
+    active = 0;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async request(value, options = {}) {
+        const url = httpsUrl(value);
+        requirePap(url.href.length <= 8192 && Buffer.byteLength(options.body ?? '') <= (this.options.maxRequestBytes ?? 1024 * 1024), 'unsafe_destination');
+        requirePap(Object.keys(options.headers ?? {}).length <= 64 && Object.entries(options.headers ?? {}).every(([key, value]) => key.length + value.length <= 131072 && !/[\r\n]/.test(key + value)), 'unsafe_destination');
+        requirePap(this.active < (this.options.maxConcurrent ?? 8), 'rate_limited');
+        this.active++;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 10000);
+        const abort = () => controller.abort();
+        options.signal?.addEventListener('abort', abort, { once: true });
+        try {
+            const host = url.hostname.replace(/^\[|\]$/g, '');
+            const lookup = this.options.lookup ?? (async (name) => dnsLookup(name, { all: true, verbatim: true }));
+            const addresses = await Promise.race([
+                isIP(host) ? Promise.resolve([{ address: host, family: isIP(host) }]) : lookup(host),
+                new Promise((_, reject) => controller.signal.addEventListener('abort', () => reject(new PapError('request_uncertain')), { once: true })),
+            ]);
+            requirePap(addresses.length > 0 && addresses.length <= 32, 'unsafe_destination');
+            const allowPrivate = this.options.privateOrigins?.includes(url.origin) === true;
+            requirePap(allowPrivate || addresses.every(item => isPublicAddress(item.address)), 'unsafe_destination');
+            requirePap(!controller.signal.aborted && !options.signal?.aborted, 'request_uncertain');
+            // Resolution is pinned to this connection. The HTTP stack never resolves the host again.
+            const address = addresses[0];
+            return await new Promise((resolve, reject) => {
+                const request = https.request(url, {
+                    method: options.method ?? 'GET', headers: { ...options.headers, host: url.host }, signal: controller.signal,
+                    ca: this.options.ca, agent: false,
+                    ...(this.options.portOverrides?.[url.origin] !== undefined && allowPrivate ? { port: this.options.portOverrides[url.origin] } : {}),
+                    lookup: ((_hostname, _options, callback) => {
+                        if (_options.all)
+                            callback(null, [address]);
+                        else
+                            callback(null, address.address, address.family);
+                    }),
+                }, response => {
+                    const chunks = [];
+                    let bytes = 0;
+                    response.on('data', (chunk) => {
+                        bytes += chunk.length;
+                        if (bytes > (this.options.maxBytes ?? 1024 * 1024)) {
+                            response.destroy();
+                            reject(new PapError('request_uncertain'));
+                        }
+                        else
+                            chunks.push(chunk);
+                    });
+                    response.on('error', () => reject(new PapError('request_uncertain')));
+                    response.on('end', () => resolve({
+                        status: response.statusCode ?? 0, body: Buffer.concat(chunks), url: url.href,
+                        headers: Object.fromEntries(Object.entries(response.headers).map(([key, value]) => [key, Array.isArray(value) ? value.join(', ') : value ?? ''])),
+                    }));
+                });
+                request.on('error', () => reject(new PapError('request_uncertain')));
+                if (options.body !== undefined)
+                    request.write(options.body);
+                request.end();
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+            options.signal?.removeEventListener('abort', abort);
+            this.active--;
+        }
+    }
+}