@ai-ecoverse/slicc-kernel 1.102.5 → 1.103.0

package/dist/types/kernel/dial.d.ts

@@ -0,0 +1,20 @@
+import { type KernelSocket, type LoopbackNet } from './socket.js';
+export interface DialPortLike {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+    start?(): void;
+    close(): void;
+}
+export type DialMessage = Uint8Array | {
+    end: true;
+} | {
+    close: true;
+} | {
+    more: true;
+} | {
+    ack: true;
+} | {
+    error: string;
+};
+export declare function dialSocket(net: LoopbackNet, port: number, host?: string): KernelSocket;
+export declare function serveSocket(socket: KernelSocket, port: DialPortLike, onClose?: () => void): () => void;

package/dist/types/kernel/epoll.d.ts

@@ -0,0 +1,67 @@
+import type { SyncFsResult } from '../realm/sync-fs-wire.js';
+import { type FdTable, type KernelFile, type PollState } from './fd-table.js';
+export declare const EPOLL: {
+    readonly IN: 1;
+    readonly OUT: 2;
+    readonly RDHUP: 4;
+    readonly PRI: 8;
+    readonly ERR: 16;
+    readonly HUP: 32;
+    readonly ET: 64;
+    readonly ONESHOT: 128;
+};
+export type EpollOp = 'add' | 'mod' | 'del' | 'set';
+export interface EpollEvent {
+    events: number;
+    data: number[];
+}
+export type EpollSyscall = {
+    op: 'epoll-create';
+} | {
+    op: 'epoll-ctl';
+    epfd: number;
+    how: EpollOp;
+    fd: number;
+    events: number;
+    data: number[];
+} | {
+    op: 'epoll-wait';
+    epfd: number;
+    max: number;
+    timeoutMs: number;
+} | {
+    op: 'eventfd-open';
+    initial: string;
+    semaphore: boolean;
+};
+export declare const EPOLL_OPS: readonly EpollSyscall['op'][];
+export interface Interest {
+    events: number;
+    gen: number;
+    reported: number;
+    armed: boolean;
+}
+export declare function levelOf(file: KernelFile): number;
+export declare function due(interest: Interest, level: number): number;
+export declare function consume(interest: Interest): void;
+export declare class EpollFile implements KernelFile {
+    private readonly regs;
+    private readonly changes;
+    private cursor;
+    ctl(fds: FdTable, how: EpollOp, fd: number, events: number, data: number[]): void;
+    reaches(target: EpollFile): boolean;
+    collect(fds: FdTable, max: number): EpollEvent[];
+    wait(fds: FdTable, max: number, timeoutMs: number, signal: AbortSignal): Promise<EpollEvent[]>;
+    poll(): PollState;
+    changed(signal?: AbortSignal): Promise<void>;
+    close(): void;
+    private register;
+    private drop;
+    private watch;
+}
+export interface EpollProcess {
+    fds: FdTable;
+    blocking(): AbortSignal;
+    owed(): boolean;
+}
+export declare function epollSyscall(req: EpollSyscall, proc: EpollProcess): Promise<SyncFsResult>;

package/dist/types/kernel/eventfd.d.ts

@@ -0,0 +1,19 @@
+import { type KernelFile, type PollState } from './fd-table.js';
+export declare const EVENTFD_MAX = 18446744073709551614n;
+export declare class Notifier {
+    private waiters;
+    wait(signal?: AbortSignal): Promise<void>;
+    wake(): void;
+}
+export declare class EventFd implements KernelFile {
+    static readonly SIZE = 8;
+    private count;
+    private readonly semaphore;
+    private readonly changes;
+    constructor(initial: bigint, semaphore: boolean);
+    read(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    write(bytes: Uint8Array, signal?: AbortSignal): Promise<number>;
+    poll(): PollState;
+    changed(signal?: AbortSignal): Promise<void>;
+    close(): void;
+}

package/dist/types/kernel/exec-ticket.d.ts

@@ -0,0 +1,25 @@
+export declare const TICKET_ENV = "SLICC_SEALED_TICKET";
+export declare const TICKET_TTL_MS = 30000;
+export declare const MAX_TICKETS = 256;
+export interface Booked {
+    pid: number;
+    path: string;
+    requested: string;
+    requestedCwd: string;
+    argv: string;
+    cwd: string;
+    at: number;
+}
+export declare function argvDigest(argv: readonly string[]): Promise<string>;
+export declare function isStrings(value: unknown): value is string[];
+export declare function stringRecord(value: unknown): Record<string, string> | undefined;
+export declare class TicketBook {
+    private readonly booked;
+    private readonly now;
+    normalise: (path: string) => Promise<string>;
+    constructor(now?: () => number);
+    get size(): number;
+    record(req: Record<string, unknown>, reply: object, pid: number): Promise<void>;
+    take(ticket: string): Booked | undefined;
+    private prune;
+}

package/dist/types/kernel/fd-table.d.ts

@@ -0,0 +1,107 @@
+import type { ClipboardChannel } from './clipboard.js';
+import type { PtyPair } from './pty.js';
+import type { SealedChannel } from './sealed.js';
+import type { KernelTty } from './tty.js';
+export type KernelErrno = 'EBADF' | 'EDEADLK' | 'ENOLCK' | 'EEXIST' | 'ELOOP' | 'EOVERFLOW' | 'ENAMETOOLONG' | 'EPIPE' | 'EMFILE' | 'EINVAL' | 'ENOENT' | 'ENOTDIR' | 'ENOEXEC' | 'ECHILD' | 'ENOSYS' | 'ESPIPE' | 'ENOSPC' | 'EINTR' | 'ESRCH' | 'ENOTTY' | 'ENXIO' | 'EPERM' | 'EIO' | 'EACCES' | 'EAGAIN' | 'ENOTSOCK' | 'EAFNOSUPPORT' | 'EPROTONOSUPPORT' | 'EOPNOTSUPP' | 'EADDRINUSE' | 'EADDRNOTAVAIL' | 'ENETUNREACH' | 'ECONNREFUSED' | 'EINPROGRESS' | 'EISCONN' | 'ENOTCONN' | 'EROFS' | 'EFBIG' | 'EALREADY' | 'ETIMEDOUT' | 'ECONNABORTED' | 'EHOSTUNREACH' | 'ECONNRESET' | 'EMSGSIZE' | 'EDESTADDRREQ' | 'ENOPROTOOPT' | 'ENOTSUP' | 'EILSEQ';
+export declare class KernelError extends Error {
+    readonly code: KernelErrno;
+    readonly detail?: string;
+    constructor(code: KernelErrno, detail?: string);
+}
+export interface PollState {
+    readable: boolean;
+    writable: boolean;
+    hangup: boolean;
+    rdhup?: boolean;
+    error?: boolean;
+}
+export interface KernelFile {
+    read?(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    peek?(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    write?(bytes: Uint8Array, signal?: AbortSignal): Promise<number>;
+    close(): void | Promise<void>;
+    poll?(): PollState;
+    changed?(signal?: AbortSignal): Promise<void>;
+    seek?(offset: number, whence: number): Promise<number>;
+    flush?(): Promise<void>;
+    pread?(max: number, at: number): Promise<Uint8Array>;
+    pwrite?(bytes: Uint8Array, at: number): Promise<number>;
+    resize?(size: number): Promise<void>;
+    stat?(): Promise<{
+        path: string;
+        size: number;
+        orphan?: true;
+    }>;
+    known?(): number | undefined;
+    tty?: KernelTty;
+    pty?: PtyPair;
+    sealed?: SealedChannel;
+    clipboard?: ClipboardChannel;
+    held?: true;
+    heldMeta?: HeldMeta;
+}
+export type HeldMeta = {
+    dir: string;
+    preopen?: string;
+    twin?: number;
+} | DeviceMeta;
+export interface DeviceMeta {
+    device: KernelDevice;
+    access?: DeviceAccess;
+}
+export type DeviceAccess = 'read' | 'write';
+export type OpenAccess = 'read' | 'write' | 'both';
+export declare function openAccess(flags: number): OpenAccess;
+export type KernelDevice = 'null' | 'zero' | 'full' | 'urandom';
+export declare function pollFile(file: KernelFile): PollState;
+export declare class OpenFile {
+    private refs;
+    private closers;
+    readonly file: KernelFile;
+    constructor(file: KernelFile);
+    retain(): this;
+    onClose(fn: () => void): () => void;
+    release(): void | Promise<void>;
+}
+export declare function openPipe(capacity?: number): {
+    read: OpenFile;
+    write: OpenFile;
+};
+export declare function bytesSource(data: Uint8Array): OpenFile;
+export declare function memoryFile(data: Uint8Array, path: string, position?: number): OpenFile;
+export declare function sinkFile(onData: (bytes: Uint8Array) => void): OpenFile;
+export declare function nullFile(): OpenFile;
+export declare function deviceAt(path: string): KernelDevice | undefined;
+export declare function deviceFile(device: KernelDevice, access?: DeviceAccess): OpenFile;
+export declare function heldFile(meta?: HeldMeta): OpenFile;
+export type KernelFdKind = 'tty' | 'stream' | 'file' | 'socket' | 'held' | 'device' | 'sealed' | 'clipboard';
+export declare function kernelFdKind(file: KernelFile): Exclude<KernelFdKind, 'socket'>;
+export interface ForkedHandles {
+    fork(): ForkedHandles;
+    clear(): void;
+}
+export declare class FdTable {
+    static readonly MAX_FDS = 1024;
+    handles: ForkedHandles | undefined;
+    private fds;
+    private readonly cloexec;
+    private readonly status;
+    get(fd: number): OpenFile;
+    stdioTerminal(): KernelTty | undefined;
+    numbers(): number[];
+    has(fd: number): boolean;
+    setCloseOnExec(fd: number): void;
+    clearCloseOnExec(fd: number): void;
+    closesOnExec(fd: number): boolean;
+    setStatusFlags(fd: number, flags: number): void;
+    statusFlags(fd: number): number | undefined;
+    install(file: OpenFile, min?: number): number;
+    installAt(fd: number, file: OpenFile): void;
+    replaceAt(fd: number, file: OpenFile): Promise<void>;
+    dup(fd: number, min?: number): number;
+    dup2(oldFd: number, newFd: number): number;
+    dup2Clipboard(oldFd: number, newFd: number): Promise<number>;
+    close(fd: number): void | Promise<void>;
+    fork(): FdTable;
+    closeAll(): Promise<void>;
+}

package/dist/types/kernel/host-ops.d.ts

@@ -0,0 +1,98 @@
+import type { SyncFsResult } from '../realm/sync-fs-wire.js';
+import { type LockKind, type LockTable } from './locks.js';
+export interface LockTarget {
+    path?: string;
+    fd?: number;
+}
+export type HostSyscall = {
+    op: 'lock';
+    path: string;
+    exclusive: boolean;
+    fd: number;
+} | {
+    op: 'unlock';
+    path: string;
+} | ({
+    op: 'lk-set';
+    kind: LockKind | 'unlock';
+    start: number;
+    len: number;
+    wait?: boolean;
+} & LockTarget) | ({
+    op: 'lk-get';
+    kind: LockKind;
+    start: number;
+    len: number;
+} & LockTarget) | ({
+    op: 'lk-close';
+} & LockTarget) | {
+    op: 'async-submit';
+    req: {
+        op: string;
+    };
+    ack?: number[];
+} | {
+    op: 'async-wait';
+    timeoutMs?: number;
+} | {
+    op: 'async-take';
+    id: number;
+} | {
+    op: 'async-resolve';
+    value: unknown;
+} | {
+    op: 'async-hold';
+} | {
+    op: 'async-cancel';
+    id: number;
+} | {
+    op: 'async-settle';
+    ids: number[];
+} | {
+    op: 'async-close';
+};
+export declare const HOST_OPS: readonly HostSyscall['op'][];
+type Run = (req: {
+    op: string;
+}, cancelled: AbortSignal) => Promise<SyncFsResult>;
+export declare class AsyncOps {
+    private next;
+    private readonly results;
+    private readonly ready;
+    private readonly running;
+    private readonly waiters;
+    private readonly taken;
+    private readonly kept;
+    private closed;
+    private readonly run;
+    private readonly onReady;
+    constructor(run: Run, onReady?: () => void);
+    submit(req: {
+        op: string;
+    }): number;
+    resolve(value: unknown): number;
+    hold(): number;
+    take(id: number): SyncFsResult;
+    ack(ids: readonly number[]): void;
+    settle(ids: readonly number[]): Promise<Array<SyncFsResult | null>>;
+    cancel(id: number): void;
+    private forget;
+    wait(timeoutMs: number | undefined, blocking: () => AbortSignal): Promise<number>;
+    close(): void;
+    private sleep;
+    private complete;
+    private wake;
+}
+export interface HostOpsContext {
+    pid: number;
+    owner?: () => number;
+    fileKey?: (target: LockTarget, kind: LockKind | 'unlock' | 'close', setting?: boolean) => Promise<string>;
+    locks: LockTable | undefined;
+    ops: AsyncOps;
+    blocking: () => AbortSignal;
+    valid: (req: {
+        op: string;
+    }) => boolean;
+}
+export declare function hostSyscall(req: HostSyscall, ctx: HostOpsContext): Promise<SyncFsResult>;
+export {};

package/dist/types/kernel/host.d.ts

@@ -0,0 +1,116 @@
+import { type Dac } from '../fs/dac.js';
+import { type PathGate } from '../fs/unlinked.js';
+import { HeldPaths } from '../mount/mount-fs.js';
+import { type SourceCheck, type SyncFsTokenEntry } from '../realm/sync-fs-token-registry.js';
+import { type BlockedMask } from '../realm/sync-sab-wire.js';
+import type { ChildForker, ChildSpawner } from './children.js';
+import type { ClipboardBroker } from './clipboard.js';
+import { type CpuTimes } from './cpu-clock.js';
+import { type Cred } from './cred.js';
+import { type FdTable, type OpenFile } from './fd-table.js';
+import type { JobTable } from './jobs.js';
+import type { LockTable } from './locks.js';
+import type { HttpHandles } from './net/http-syscalls.js';
+import type { Resolver } from './net/resolver.js';
+import type { MountLine, ProcessListing } from './proc-info.js';
+import { type StateListener, type WasmProcessOptions, type WasmSyscall } from './process.js';
+import { type ForkState, type InheritedFd, type Program } from './protocol.js';
+import type { PtyTable } from './pty.js';
+import type { SealedBroker } from './sealed.js';
+import type { SemTable } from './sem.js';
+import { type LoopbackNet } from './socket.js';
+import type { VfsNodes } from './vfs-file.js';
+export interface WasmWorkerLike {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message' | 'error', handler: (event: MessageEvent) => void): void;
+    removeEventListener(type: 'message' | 'error', handler: (event: MessageEvent) => void): void;
+    terminate(): void;
+}
+export interface SpawnWasmOptions {
+    pid: number;
+    changes?: SharedArrayBuffer;
+    ignored?: number;
+    blocked?: BlockedMask;
+    umask?: number;
+    cred?: Cred;
+    owners?: boolean;
+    links?: number;
+    fresh?: (path: string, umask: number) => void;
+    source?: SourceCheck;
+    sealed?: SealedBroker;
+    outputFilter?: (file: OpenFile) => OpenFile;
+    clipboard?: ClipboardBroker;
+    readonlyAt?: (path: string) => boolean;
+    dac?: Dac;
+    identity?: () => Promise<{
+        pid: number;
+        ppid: number;
+    }>;
+    onSyscall?: (req: WasmSyscall) => void;
+    settling?: () => boolean;
+    program: Program;
+    argv0: string;
+    args: string[];
+    env: Record<string, string>;
+    cwd: string;
+    fds: FdTable;
+    fs: SyncFsTokenEntry['fs'];
+    noLinks: SyncFsTokenEntry['fs'];
+    createWorker: () => WasmWorkerLike;
+    onError?: (message: string) => void;
+    spawner?: ChildSpawner;
+    forker?: ChildForker;
+    fork?: ForkState;
+    ppid?: number;
+    shownPid?: number;
+    kill?: (pid: number, sig: number) => boolean | Promise<boolean>;
+    writesBack?: (pid: number) => boolean;
+    processes?: () => ProcessListing;
+    sudo?: WasmProcessOptions['sudo'];
+    openFiles?: Set<VfsNodes>;
+    nodes?: VfsNodes;
+    statfs?: (path: string) => Promise<{
+        quota: number;
+        usage: number;
+    } | undefined>;
+    mounts?: () => MountLine[];
+    mount?: WasmProcessOptions['mount'];
+    umount?: WasmProcessOptions['umount'];
+    held?: Set<HeldPaths>;
+    unlinkGate?: PathGate;
+    jobs?: JobTable;
+    ptys?: PtyTable;
+    net?: LoopbackNet;
+    http?: HttpHandles;
+    locks?: LockTable;
+    sems?: SemTable;
+    onReap?: (pid: number) => void;
+    resolver?: Resolver;
+}
+export interface WasmProcessHandle {
+    pid: number;
+    exited: Promise<number>;
+    kill(code?: number): void;
+    signal(sig: number): void;
+    termsig(): number | undefined;
+    onState(listener: StateListener): void;
+    memory(): number;
+    ignoredSignals(fork?: boolean): number;
+    blockedSignals?(): BlockedMask;
+    signalMasks?(): {
+        ignored: number;
+        caught: number;
+    };
+    umask?(): number;
+    cred?(): Cred;
+    writesBack(): boolean;
+    times?(): CpuTimes | undefined;
+    running?(): number;
+    threads?(): Array<{
+        tid: number;
+        state: 'R' | 'S';
+    }>;
+}
+export declare const KILL_GRACE_MS = 2000;
+export declare function inheritedFds(fds: FdTable): InheritedFd[];
+export declare function spawnWasmProcess(opts: SpawnWasmOptions): WasmProcessHandle;

package/dist/types/kernel/jobs.d.ts

@@ -0,0 +1,50 @@
+import type { KernelTty } from './tty.js';
+export interface JobMember {
+    pid: number;
+    pgid: number;
+    sid: number;
+    signal(sig: number): void;
+    execParent?: number;
+    ppid?: number;
+    execed?: boolean;
+    shownAs?: number;
+}
+export declare class JobTable {
+    private readonly members;
+    private readonly handoffs;
+    private readonly foreground;
+    private readonly terminals;
+    keyboard: boolean;
+    add(pid: number, parentPid: number | undefined, signal: (sig: number) => void, terminal?: KernelTty): JobMember;
+    list(): JobMember[];
+    remove(pid: number): void;
+    private prune;
+    exec(pid: number, child: number, adopt?: boolean): void;
+    shown(pid: number): number;
+    shownParent(pid: number): number | undefined;
+    sessionOf(pgid: number): number | undefined;
+    join(pid: number, pgid: number): void;
+    lead(pid: number): void;
+    pgidOf(pid: number): number | undefined;
+    sidOf(pid: number): number | undefined;
+    private member;
+    private idOf;
+    private byId;
+    setpgid(caller: number, pid: number, pgid: number): void;
+    get handoffCount(): number;
+    getpgid(caller: number, pid: number): number;
+    getsid(caller: number, pid: number): number;
+    setsid(pid: number): number;
+    terminalNamed(name: string): KernelTty | undefined;
+    terminalNames(): string[];
+    private knownTerminals;
+    controllingTerminal(pid: number): KernelTty | null | undefined;
+    acquireTerminal(pid: number, tty: KernelTty): boolean;
+    killGroup(pgid: number, sig: number, may?: (pid: number) => boolean): boolean;
+    tcgetpgrp(tty: KernelTty, fallback: number): number;
+    tcsetpgrp(caller: number, tty: KernelTty, pgid: number, settling?: boolean): void;
+    private reclaimed;
+    signalOwnedForeground(tty: KernelTty, sig: number): void;
+    signalForeground(tty: KernelTty, fallback: number, sig: number): void;
+    fromKeyboard(send: () => void): void;
+}

package/dist/types/kernel/locks.d.ts

@@ -0,0 +1,40 @@
+export type LockKind = 'read' | 'write';
+export interface RecordLock {
+    owner: number;
+    kind: LockKind;
+    start: number;
+    end: number;
+}
+interface Blocked {
+    key: string;
+    kind: LockKind;
+    start: number;
+    end: number;
+}
+export declare function lockRange(start: number, len: number): {
+    start: number;
+    end: number;
+};
+export declare class LockTable {
+    private readonly records;
+    private readonly blocked;
+    private readonly wakers;
+    private readonly held;
+    holder(key: string, owner: number, want: Blocked): RecordLock | undefined;
+    set(key: string, owner: number, kind: LockKind | 'unlock', start: number, end: number): boolean;
+    wait(key: string, owner: number, kind: LockKind, range: {
+        start: number;
+        end: number;
+    }, blocking: () => AbortSignal): Promise<void>;
+    private waitsOn;
+    private changed;
+    private wake;
+    private store;
+    holds(owner: number): boolean;
+    dropFile(key: string, owner: number): void;
+    lock(pid: number, path: string, exclusive: boolean, fd: number): boolean;
+    unlock(pid: number, path: string): void;
+    closed(pid: number, fd: number): void;
+    release(pid: number): void;
+}
+export {};

package/dist/types/kernel/net/datagram-wire.d.ts

@@ -0,0 +1,8 @@
+export interface Received {
+    bytes: Uint8Array;
+    host: string;
+    port: number;
+    truncated: boolean;
+}
+export declare function encodeReceived(got: Received): Uint8Array;
+export declare function decodeReceived(raw: Uint8Array): Received;

package/dist/types/kernel/net/http-syscalls.d.ts

@@ -0,0 +1,58 @@
+import type { SyncFsResult } from '../../realm/sync-fs-wire.js';
+import { type KernelLoopback } from './loopback-transport.js';
+import type { HeaderList, RealmTransport } from './transport.js';
+import { type WsSyscall } from './ws-syscalls.js';
+export interface HttpRequestBody {
+    url: string;
+    method: string;
+    headers: HeaderList;
+    body?: Uint8Array;
+}
+export type HttpSyscall = ({
+    op: 'net-request';
+} & HttpRequestBody) | ({
+    op: 'net-open';
+} & HttpRequestBody) | {
+    op: 'net-head';
+    handle: number;
+} | {
+    op: 'net-read';
+    handle: number;
+    max: number;
+} | {
+    op: 'net-close';
+    handle: number;
+} | {
+    op: 'net-traits';
+    url?: string;
+} | WsSyscall;
+export declare const HTTP_OPS: readonly string[];
+export interface HttpHead {
+    handle: number;
+    status: number;
+    statusText: string;
+    url: string;
+    redirected?: boolean;
+    headers: HeaderList;
+}
+export declare class HttpHandles {
+    private readonly transport;
+    private readonly open;
+    private nextHandle;
+    private readonly ws;
+    private readonly owner;
+    private readonly local;
+    constructor(transport: RealmTransport, owner?: number, local?: KernelLoopback);
+    syscall(req: HttpSyscall): Promise<SyncFsResult>;
+    private traits;
+    private request;
+    private opened;
+    private start;
+    private respond;
+    private headOf;
+    private head;
+    private read;
+    private take;
+    private close;
+    closeAll(): Promise<void>;
+}

package/dist/types/kernel/net/http1.d.ts

@@ -0,0 +1,48 @@
+import type { HeaderList } from './transport.js';
+export interface ByteSource {
+    read(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+}
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare const REASON: Readonly<Record<number, string>>;
+export declare class Incoming {
+    private readonly source;
+    private buf;
+    private eof;
+    constructor(source: ByteSource);
+    get buffered(): number;
+    private fill;
+    private take;
+    peek(signal?: AbortSignal): Promise<number | undefined>;
+    some(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    head(limit: number, signal?: AbortSignal): Promise<Uint8Array | null>;
+    line(limit: number, signal?: AbortSignal): Promise<string>;
+    exactly(n: number, signal?: AbortSignal): Promise<Uint8Array>;
+}
+export declare function latin1(bytes: Uint8Array): string;
+export declare function latin1Bytes(text: string): Uint8Array;
+export interface RequestHead {
+    method: string;
+    target: string;
+    minor: number;
+    headers: HeaderList;
+}
+export declare function parseRequestHead(bytes: Uint8Array): RequestHead;
+export declare function fieldValues(headers: HeaderList, name: string): string[];
+export declare function fieldTokens(headers: HeaderList, name: string): string[];
+export type BodyFraming = {
+    kind: 'none';
+} | {
+    kind: 'length';
+    length: number;
+} | {
+    kind: 'chunked';
+};
+export declare function requestFraming(headers: HeaderList): BodyFraming;
+export declare function readBody(incoming: Incoming, framing: BodyFraming, cap: number, signal?: AbortSignal): Promise<Uint8Array | undefined>;
+export declare function concat(chunks: Uint8Array[], total?: number): Uint8Array<ArrayBuffer>;
+export declare function responseHead(status: number, reason: string, headers: HeaderList): Uint8Array;
+export declare function chunk(bytes: Uint8Array): Uint8Array;
+export declare const LAST_CHUNK: Uint8Array<ArrayBufferLike>;

package/dist/types/kernel/net/loopback-names.d.ts

@@ -0,0 +1,14 @@
+export declare const HOST_LOOPBACK = "host.slicc.internal";
+export declare const HOST_LOOPBACK_ADDRESS: readonly [10, 0, 2, 2];
+export declare const PAGE_LOOPBACK = "kernel.localhost";
+export declare const PAGE_LOOPBACK_URL = "http://{port}.kernel.localhost";
+export declare function toHostLoopback(href: string): string;
+export declare function isKernelLoopbackHost(hostname: string): boolean;
+export declare function kernelLoopbackPort(href: string): number | undefined;
+export declare const DEFAULT_HOSTNAME = "slicc";
+export declare const HOSTNAME_ADDRESS = "127.0.1.1";
+export declare const LIBC_HOSTNAMES: readonly string[];
+export declare function isHostname(name: unknown): name is string;
+export declare function hostnameOf(env: Readonly<Record<string, string>>): string;
+export declare function ownNames(hostname: string): string[];
+export declare function hostsFile(hostname?: string): string;