@abot-ai/runtime 1.2.0 → 1.3.1

package/dist/src/sessions/session-service.js

@@ -200,6 +200,7 @@ export class SessionService {
                 taskType: options.taskType,
                 requestId: options.requestId,
                 cronJobId: options.cronJobId,
+                ...(options.schedule ? { schedule: options.schedule } : {}),
                 cronTitle: options.cronTitle,
                 triggerType: options.triggerType,
                 attachments: options.attachments,

package/dist/src/sessions/types.d.ts

@@ -86,6 +86,7 @@ export type SessionListResult = {
     nextCursor: string | null;
 };
 export type SessionSnapshotMessage = {
+    schedule?: import("./schedule-metadata.js").ScheduleMessageReference;
     id: string | number;
     sessionId: string;
     role: SessionMessageRole;
@@ -137,6 +138,7 @@ export type SessionMessageDeleteResult = {
     deletedRequestEvents?: number;
 };
 export type SessionMessage = {
+    schedule?: import("./schedule-metadata.js").ScheduleMessageReference;
     id: string;
     role: SessionMessageRole;
     content: string;

package/dist/src/shared/directory-authority/bootstrap.d.ts

@@ -0,0 +1 @@
+export declare function directoryAuthorityScript(mode: "task" | "command", messageLimit: number, task?: (input: never) => unknown): string;

package/dist/src/shared/directory-authority/bootstrap.js

@@ -0,0 +1,118 @@
+/**
+ * This function is serialized into a fresh Node process. It must remain
+ * closure-free and use only node: built-ins; the starting cwd is untrusted
+ * until its identity has been compared with the inherited directory handle.
+ */
+function directoryAuthorityBootstrap(mode, messageLimit, task) {
+    const fs = require("node:fs");
+    function fail(code, message) {
+        throw Object.assign(new Error(message), { code });
+    }
+    function verifyDirectoryAuthority() {
+        const expected = fs.fstatSync(3, { bigint: true });
+        const actual = fs.statSync(".", { bigint: true });
+        const matchesHeldDirectory = expected.isDirectory() &&
+            actual.isDirectory() &&
+            expected.dev === actual.dev &&
+            expected.ino === actual.ino;
+        if (matchesHeldDirectory)
+            return;
+        fail("directory_authority_changed", "The directory changed before the operation could establish its authority.");
+    }
+    function readRequest() {
+        const fd = mode === "task" ? 0 : 4;
+        const chunk = Buffer.alloc(64 * 1024);
+        const chunks = [];
+        let total = 0;
+        for (;;) {
+            const length = fs.readSync(fd, chunk, 0, chunk.length, null);
+            if (length === 0)
+                break;
+            total += length;
+            if (total > messageLimit) {
+                fail("directory_authority_request_too_large", "The directory operation input exceeds the bridge byte limit.");
+            }
+            chunks.push(Buffer.from(chunk.subarray(0, length)));
+        }
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    function reportFailure(error) {
+        const detail = error;
+        const code = typeof detail?.code === "string"
+            ? detail.code.slice(0, 256)
+            : "directory_authority_failed";
+        const message = typeof detail?.message === "string"
+            ? detail.message.slice(0, 4096)
+            : "The directory operation failed.";
+        let encoded;
+        try {
+            encoded = JSON.stringify({
+                ok: false,
+                error: { code, message, data: detail?.data },
+            });
+            if (Buffer.byteLength(encoded) > messageLimit)
+                throw new Error();
+        }
+        catch {
+            encoded = JSON.stringify({ ok: false, error: { code, message } });
+        }
+        writeResponse(mode === "task" ? 1 : 2, encoded);
+        process.exitCode = mode === "task" ? 0 : 125;
+    }
+    function writeResponse(fd, encoded) {
+        const bytes = Buffer.from(encoded);
+        let offset = 0;
+        while (offset < bytes.length) {
+            offset += fs.writeSync(fd, bytes, offset, bytes.length - offset);
+        }
+    }
+    async function runTask(input) {
+        if (!task)
+            fail("directory_authority_failed", "The directory task is missing.");
+        const result = await task(input);
+        const encoded = JSON.stringify({ ok: true, result });
+        if (Buffer.byteLength(encoded) > messageLimit) {
+            fail("directory_authority_result_too_large", "The directory operation result exceeds the bridge byte limit.");
+        }
+        writeResponse(1, encoded);
+    }
+    function runCommand(input) {
+        const { spawn } = require("node:child_process");
+        const command = input;
+        // Omitting cwd inherits the kernel-pinned authority. Resolving cwd() back
+        // into a pathname here would reopen the race this bridge prevents.
+        const child = spawn(command.command, command.args, {
+            stdio: ["ignore", "inherit", "inherit"],
+            env: process.env,
+        });
+        child.once("error", reportFailure);
+        child.once("exit", (code, signal) => {
+            if (signal) {
+                process.kill(process.pid, signal);
+                return;
+            }
+            if (typeof code === "number")
+                process.exitCode = code;
+        });
+    }
+    try {
+        verifyDirectoryAuthority();
+        const input = readRequest();
+        if (mode === "command") {
+            runCommand(input);
+            return;
+        }
+        void runTask(input).catch(reportFailure);
+    }
+    catch (error) {
+        reportFailure(error);
+    }
+}
+export function directoryAuthorityScript(mode, messageLimit, task) {
+    const taskSource = task ? `(${task.toString()})` : "undefined";
+    // tsx preserves nested function names with esbuild's __name annotation.
+    // Include that annotation's definition so the same trusted task works in
+    // development and in the production bundle without rewriting its source.
+    const preserveFunctionName = "const __name=(target,value)=>Object.defineProperty(target,'name',{value,configurable:true});";
+    return `${preserveFunctionName}(${directoryAuthorityBootstrap.toString()})(${JSON.stringify(mode)},${messageLimit},${taskSource});`;
+}

package/dist/src/shared/directory-authority/command.d.ts

@@ -0,0 +1,8 @@
+import { type ChildProcessByStdio } from "node:child_process";
+import type { Readable } from "node:stream";
+import { type DirectoryAuthorityLocation } from "./protocol.js";
+export declare function spawnDirectoryAuthorityCommand(input: DirectoryAuthorityLocation & Readonly<{
+    command: string;
+    args: readonly string[];
+    env?: NodeJS.ProcessEnv;
+}>): ChildProcessByStdio<null, Readable, Readable>;

package/dist/src/shared/directory-authority/command.js

@@ -0,0 +1,27 @@
+import { spawn } from "node:child_process";
+import { directoryAuthorityScript } from "./bootstrap.js";
+import { assertDirectoryAuthorityLocation, authorityEnvironment, AUTHORITY_MESSAGE_LIMIT, encodeAuthorityRequest, } from "./protocol.js";
+export function spawnDirectoryAuthorityCommand(input) {
+    assertDirectoryAuthorityLocation(input);
+    const request = encodeAuthorityRequest({
+        command: input.command,
+        args: input.args,
+    });
+    const child = spawn(process.execPath, [
+        "--input-type=commonjs",
+        "-e",
+        directoryAuthorityScript("command", AUTHORITY_MESSAGE_LIMIT),
+    ], {
+        cwd: input.directoryPath,
+        env: authorityEnvironment(input.env),
+        detached: true,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "pipe", input.directoryFd, "pipe"],
+    });
+    const requestPipe = child.stdio[4];
+    // An early authority failure may close the request pipe before the parent
+    // finishes writing. The process result remains the authoritative error.
+    requestPipe?.on("error", () => undefined);
+    requestPipe?.end(request);
+    return child;
+}

package/dist/src/shared/directory-authority/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class DirectoryAuthorityError extends Error {
+    readonly code: string;
+    readonly data?: Readonly<Record<string, unknown>> | undefined;
+    constructor(code: string, message: string, data?: Readonly<Record<string, unknown>> | undefined);
+}

package/dist/src/shared/directory-authority/errors.js

@@ -0,0 +1,10 @@
+export class DirectoryAuthorityError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "DirectoryAuthorityError";
+    }
+}

package/dist/src/shared/directory-authority/index.d.ts

@@ -0,0 +1,3 @@
+export { spawnDirectoryAuthorityCommand } from "./command.js";
+export { DirectoryAuthorityError } from "./errors.js";
+export { runDirectoryAuthorityTask } from "./task.js";

package/dist/src/shared/directory-authority/index.js

@@ -0,0 +1,3 @@
+export { spawnDirectoryAuthorityCommand } from "./command.js";
+export { DirectoryAuthorityError } from "./errors.js";
+export { runDirectoryAuthorityTask } from "./task.js";

package/dist/src/shared/directory-authority/protocol.d.ts

@@ -0,0 +1,11 @@
+export declare const AUTHORITY_MESSAGE_LIMIT: number;
+export declare const AUTHORITY_STDERR_LIMIT: number;
+export declare const AUTHORITY_TASK_TIMEOUT_MS = 30000;
+export type DirectoryAuthorityLocation = Readonly<{
+    directoryPath: string;
+    directoryFd: number;
+}>;
+export declare function assertDirectoryAuthorityLocation(location: DirectoryAuthorityLocation): void;
+export declare function authorityEnvironment(environment?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function encodeAuthorityRequest(input: unknown): string;
+export declare function decodeAuthorityResult<Result>(output: string): Result;

package/dist/src/shared/directory-authority/protocol.js

@@ -0,0 +1,62 @@
+import { isAbsolute } from "node:path";
+import { DirectoryAuthorityError } from "./errors.js";
+export const AUTHORITY_MESSAGE_LIMIT = 8 * 1024 * 1024;
+export const AUTHORITY_STDERR_LIMIT = 16 * 1024;
+export const AUTHORITY_TASK_TIMEOUT_MS = 30_000;
+export function assertDirectoryAuthorityLocation(location) {
+    if (!isAbsolute(location.directoryPath)) {
+        throw new DirectoryAuthorityError("directory_authority_invalid_path", "The directory authority requires an absolute starting path.");
+    }
+    const hasOpenDescriptorNumber = Number.isInteger(location.directoryFd) && location.directoryFd >= 0;
+    if (hasOpenDescriptorNumber)
+        return;
+    throw new DirectoryAuthorityError("directory_authority_invalid_fd", "The directory authority requires an open directory descriptor.");
+}
+export function authorityEnvironment(environment = process.env) {
+    const sanitized = { ...environment };
+    delete sanitized.NODE_OPTIONS;
+    delete sanitized.NODE_PATH;
+    return sanitized;
+}
+export function encodeAuthorityRequest(input) {
+    let encoded;
+    try {
+        encoded = JSON.stringify(input);
+    }
+    catch {
+        throw new DirectoryAuthorityError("directory_authority_invalid_request", "The directory operation input must be JSON serializable.");
+    }
+    if (encoded === undefined) {
+        throw new DirectoryAuthorityError("directory_authority_invalid_request", "The directory operation input must be JSON serializable.");
+    }
+    if (Buffer.byteLength(encoded) <= AUTHORITY_MESSAGE_LIMIT)
+        return encoded;
+    throw new DirectoryAuthorityError("directory_authority_request_too_large", "The directory operation input exceeds the bridge byte limit.");
+}
+function isAuthorityMessageObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function decodeAuthorityResult(output) {
+    let message;
+    try {
+        message = JSON.parse(output);
+    }
+    catch {
+        throw new DirectoryAuthorityError("directory_authority_protocol_error", "The directory operation returned an invalid response.");
+    }
+    if (!isAuthorityMessageObject(message)) {
+        throw new DirectoryAuthorityError("directory_authority_protocol_error", "The directory operation returned an invalid response.");
+    }
+    if (message.ok === true)
+        return message.result;
+    const hasAuthorityError = message.ok === false && isAuthorityMessageObject(message.error);
+    if (!hasAuthorityError) {
+        throw new DirectoryAuthorityError("directory_authority_protocol_error", "The directory operation returned an invalid response.");
+    }
+    const { code, message: explanation, data, } = message.error;
+    const hasErrorDescription = typeof code === "string" && typeof explanation === "string";
+    if (!hasErrorDescription) {
+        throw new DirectoryAuthorityError("directory_authority_protocol_error", "The directory operation returned an invalid error response.");
+    }
+    throw new DirectoryAuthorityError(code, explanation, isAuthorityMessageObject(data) ? data : undefined);
+}

package/dist/src/shared/directory-authority/task.d.ts

@@ -0,0 +1,7 @@
+import { type DirectoryAuthorityLocation } from "./protocol.js";
+export declare function runDirectoryAuthorityTask<Input, Result>(input: DirectoryAuthorityLocation & Readonly<{
+    input: Input;
+    task: (input: Input) => Result | Promise<Result>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}>): Promise<Result>;

package/dist/src/shared/directory-authority/task.js

@@ -0,0 +1,97 @@
+import { spawn } from "node:child_process";
+import { directoryAuthorityScript } from "./bootstrap.js";
+import { DirectoryAuthorityError } from "./errors.js";
+import { assertDirectoryAuthorityLocation, authorityEnvironment, AUTHORITY_MESSAGE_LIMIT, AUTHORITY_STDERR_LIMIT, AUTHORITY_TASK_TIMEOUT_MS, decodeAuthorityResult, encodeAuthorityRequest, } from "./protocol.js";
+export async function runDirectoryAuthorityTask(input) {
+    assertDirectoryAuthorityLocation(input);
+    const request = encodeAuthorityRequest(input.input);
+    const timeoutMs = input.timeoutMs ?? AUTHORITY_TASK_TIMEOUT_MS;
+    const hasPositiveDeadline = Number.isFinite(timeoutMs) && timeoutMs > 0;
+    if (!hasPositiveDeadline) {
+        throw new DirectoryAuthorityError("directory_authority_invalid_timeout", "The directory operation deadline must be a positive finite duration.");
+    }
+    if (input.signal?.aborted) {
+        throw new DirectoryAuthorityError("directory_authority_aborted", "The directory operation was cancelled before it started.");
+    }
+    const child = spawn(process.execPath, [
+        "--input-type=commonjs",
+        "-e",
+        directoryAuthorityScript("task", AUTHORITY_MESSAGE_LIMIT, input.task),
+    ], {
+        cwd: input.directoryPath,
+        env: authorityEnvironment(),
+        detached: true,
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe", input.directoryFd],
+    });
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const stderrChunks = [];
+        let bytes = 0;
+        let stderrBytes = 0;
+        let failure;
+        const stop = (error) => {
+            if (failure)
+                return;
+            failure = error;
+            if (typeof child.pid === "number") {
+                try {
+                    process.kill(-child.pid, "SIGKILL");
+                    return;
+                }
+                catch {
+                    // A process which has already exited may no longer own its group.
+                }
+            }
+            child.kill("SIGKILL");
+        };
+        const onAbort = () => stop(new DirectoryAuthorityError("directory_authority_aborted", "The directory operation was cancelled."));
+        const timer = setTimeout(() => stop(new DirectoryAuthorityError("directory_authority_timeout", "The directory operation exceeded its deadline.")), timeoutMs);
+        timer.unref();
+        input.signal?.addEventListener("abort", onAbort, { once: true });
+        if (input.signal?.aborted)
+            onAbort();
+        child.stdout.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > AUTHORITY_MESSAGE_LIMIT) {
+                stop(new DirectoryAuthorityError("directory_authority_result_too_large", "The directory operation result exceeds the bridge byte limit."));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            const remaining = Math.max(AUTHORITY_STDERR_LIMIT - stderrBytes, 0);
+            if (remaining === 0)
+                return;
+            stderrChunks.push(chunk.subarray(0, remaining));
+            stderrBytes += Math.min(chunk.length, remaining);
+        });
+        child.stdin.on("error", () => undefined);
+        child.once("error", (error) => {
+            failure ??= new DirectoryAuthorityError("directory_authority_unavailable", `The directory operation could not start: ${error.message}`);
+        });
+        child.once("close", (code, signal) => {
+            clearTimeout(timer);
+            input.signal?.removeEventListener("abort", onAbort);
+            if (failure) {
+                reject(failure);
+                return;
+            }
+            if (code !== 0) {
+                reject(new DirectoryAuthorityError("directory_authority_failed", "The directory operation process did not complete successfully.", {
+                    exitCode: code,
+                    signal,
+                    stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                }));
+                return;
+            }
+            try {
+                resolve(decodeAuthorityResult(Buffer.concat(chunks).toString("utf8")));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        child.stdin.end(request);
+    });
+}

package/dist/src/shared/http-server-shutdown.d.ts

@@ -0,0 +1,4 @@
+import type { Server } from "node:http";
+import type { WebSocketServer } from "ws";
+/** Stops only this server's connections; active work is not drained on shutdown. */
+export declare function closeHttpServerImmediately(server: Server, webSockets?: WebSocketServer): Promise<void>;

package/dist/src/shared/http-server-shutdown.js

@@ -0,0 +1,17 @@
+/** Stops only this server's connections; active work is not drained on shutdown. */
+export function closeHttpServerImmediately(server, webSockets) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+        // Stop accepting first: a connection cannot arrive between the sweep and close.
+        server.closeAllConnections();
+        webSockets?.close();
+        for (const client of webSockets?.clients ?? [])
+            client.terminate();
+    });
+}

package/dist/src/shared/public-http/aggregate-gate.d.ts

@@ -0,0 +1,3 @@
+export declare function createAggregateGate(maxActive: number, maxQueued: number): Readonly<{
+    run<T>(operation: () => Promise<T>, deadline: number, abortSignal?: AbortSignal): Promise<T>;
+}>;

package/dist/src/shared/public-http/aggregate-gate.js

@@ -0,0 +1,87 @@
+import { remainingTime, withinDeadline } from "./deadline.js";
+import { PublicHttpError } from "./errors.js";
+export function createAggregateGate(maxActive, maxQueued) {
+    let active = 0;
+    const queue = [];
+    const startQueued = () => {
+        while (active < maxActive && queue.length > 0) {
+            const waiter = queue.shift();
+            clearTimeout(waiter.timeout);
+            if (waiter.onAbort) {
+                waiter.abortSignal?.removeEventListener("abort", waiter.onAbort);
+            }
+            if (waiter.abortSignal?.aborted) {
+                waiter.reject(new PublicHttpError("web_request_aborted", "The web request was aborted."));
+                continue;
+            }
+            if (waiter.deadline <= Date.now()) {
+                waiter.reject(new PublicHttpError("web_request_timed_out", "The upstream web request timed out."));
+                continue;
+            }
+            active += 1;
+            let released = false;
+            waiter.resolve(() => {
+                if (released)
+                    return;
+                released = true;
+                active -= 1;
+                startQueued();
+            });
+        }
+    };
+    const acquire = (deadline, abortSignal) => {
+        if (abortSignal?.aborted) {
+            return Promise.reject(new PublicHttpError("web_request_aborted", "The web request was aborted."));
+        }
+        if (active < maxActive) {
+            active += 1;
+            let released = false;
+            return Promise.resolve(() => {
+                if (released)
+                    return;
+                released = true;
+                active -= 1;
+                startQueued();
+            });
+        }
+        if (queue.length >= maxQueued) {
+            return Promise.reject(new PublicHttpError("web_request_capacity_exceeded", "The web client is at its bounded request capacity."));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve,
+                reject,
+                deadline,
+                ...(abortSignal ? { abortSignal } : {}),
+            };
+            const remove = () => {
+                const index = queue.indexOf(waiter);
+                if (index >= 0)
+                    queue.splice(index, 1);
+            };
+            const fail = (error) => {
+                remove();
+                clearTimeout(waiter.timeout);
+                if (waiter.onAbort) {
+                    abortSignal?.removeEventListener("abort", waiter.onAbort);
+                }
+                reject(error);
+            };
+            waiter.onAbort = () => fail(new PublicHttpError("web_request_aborted", "The web request was aborted."));
+            waiter.timeout = setTimeout(() => fail(new PublicHttpError("web_request_timed_out", "The upstream web request timed out.")), remainingTime(deadline));
+            waiter.timeout.unref?.();
+            abortSignal?.addEventListener("abort", waiter.onAbort, { once: true });
+            queue.push(waiter);
+        });
+    };
+    return Object.freeze({
+        async run(operation, deadline, abortSignal) {
+            const release = await acquire(deadline, abortSignal);
+            const rawWork = Promise.resolve().then(operation);
+            // A deadline rejects the visible operation promptly, but the capacity slot
+            // remains held until non-cancellable DNS or transport work actually settles.
+            void rawWork.then(release, release);
+            return await withinDeadline(rawWork, deadline, abortSignal);
+        },
+    });
+}

package/dist/src/shared/public-http/deadline.d.ts

@@ -0,0 +1,2 @@
+export declare function remainingTime(deadline: number): number;
+export declare function withinDeadline<T>(promise: Promise<T>, deadline: number, abortSignal?: AbortSignal): Promise<T>;

package/dist/src/shared/public-http/deadline.js

@@ -0,0 +1,29 @@
+import { PublicHttpError } from "./errors.js";
+export function remainingTime(deadline) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+        throw new PublicHttpError("web_request_timed_out", "The upstream web request timed out.");
+    }
+    return remaining;
+}
+export function withinDeadline(promise, deadline, abortSignal) {
+    if (abortSignal?.aborted) {
+        return Promise.reject(new PublicHttpError("web_request_aborted", "The web request was aborted."));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (operation) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            abortSignal?.removeEventListener("abort", onAbort);
+            operation();
+        };
+        const onAbort = () => finish(() => reject(new PublicHttpError("web_request_aborted", "The web request was aborted.")));
+        const timeout = setTimeout(() => finish(() => reject(new PublicHttpError("web_request_timed_out", "The upstream web request timed out."))), remainingTime(deadline));
+        timeout.unref?.();
+        abortSignal?.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+    });
+}

package/dist/src/shared/public-http/errors.d.ts

@@ -0,0 +1,6 @@
+export type PublicHttpErrorCode = "web_request_aborted" | "web_request_timed_out" | "web_request_capacity_exceeded" | "web_target_invalid" | "web_target_not_public" | "web_target_unresolvable" | "web_redirect_invalid" | "web_redirect_limit_exceeded" | "web_response_invalid";
+export declare class PublicHttpError<Code extends string = PublicHttpErrorCode> extends Error {
+    readonly code: Code;
+    constructor(code: Code, message: string);
+}
+export declare function isPublicHttpError(error: unknown): error is PublicHttpError;

package/dist/src/shared/public-http/errors.js

@@ -0,0 +1,11 @@
+export class PublicHttpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "PublicHttpError";
+        this.code = code;
+    }
+}
+export function isPublicHttpError(error) {
+    return error instanceof PublicHttpError;
+}

package/dist/src/shared/public-http/limits.d.ts

@@ -0,0 +1,8 @@
+export declare const PUBLIC_HTTP_LIMITS: Readonly<{
+    readonly httpConcurrency: 6;
+    readonly httpQueueLimit: 64;
+    readonly redirects: 3;
+    readonly responseBytes: number;
+    readonly requestTimeoutMs: 10000;
+    readonly responseHeaderBytes: number;
+}>;

package/dist/src/shared/public-http/limits.js

@@ -0,0 +1,8 @@
+export const PUBLIC_HTTP_LIMITS = Object.freeze({
+    httpConcurrency: 6,
+    httpQueueLimit: 64,
+    redirects: 3,
+    responseBytes: 512 * 1024,
+    requestTimeoutMs: 10_000,
+    responseHeaderBytes: 32 * 1024,
+});

package/dist/src/shared/public-http/network-policy.d.ts

@@ -0,0 +1,11 @@
+export type PublicAddress = Readonly<{
+    address: string;
+    family: 4 | 6;
+}>;
+export type HostResolver = (hostname: string) => Promise<readonly PublicAddress[]>;
+export declare function isPublicIpv4(address: string): boolean;
+export declare function isPublicIpv6(address: string): boolean;
+export declare function isPublicAddress(address: PublicAddress): boolean;
+export declare function parsePublicHttpUrl(rawUrl: string): URL;
+export declare const resolveHostAddresses: HostResolver;
+export declare function resolvePublicTarget(url: URL, resolver?: HostResolver): Promise<PublicAddress>;