@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

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;

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

@@ -0,0 +1,13 @@
+import type { ConnectorStamp, LoopbackNet, PeerCred } from '../socket.js';
+import type { RealmTransportRequest, RealmTransportResponse, RealmTransportTraits, RealmWebSocket, RealmWebSocketRequest } from './transport.js';
+export declare const LOOPBACK_TRAITS: RealmTransportTraits;
+export declare class KernelLoopback {
+    private readonly net;
+    private readonly cred;
+    private readonly stamp?;
+    constructor(net: LoopbackNet, cred: () => PeerCred, stamp?: () => Promise<ConnectorStamp>);
+    port(url: string): number | undefined;
+    private connect;
+    fetch(req: RealmTransportRequest, port: number): Promise<RealmTransportResponse>;
+    websocket(req: RealmWebSocketRequest, port: number): Promise<RealmWebSocket>;
+}

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

@@ -0,0 +1,29 @@
+import type { KernelFs } from '../../fs/types.js';
+import type { LoopbackNet } from '../socket.js';
+import { RealmProxy } from './proxy-service.js';
+import { type CaStore, type RealmCa } from './realm-ca.js';
+import { type TlsEngine, type TlsEngineModule } from './tls-engine.js';
+import type { RealmTransport } from './transport.js';
+export declare const NO_TRANSPORT = "slicc-kernel: no network transport (createKernel({ network: { transport } }))";
+export declare const TLS_ENGINE_PACKAGE = "@ai-ecoverse/wasm-tls-engine";
+export declare const CA_PATH = "/etc/ssl/certs/slicc-kernel-ca.pem";
+export declare const CA_DB = "slicc-kernel-ca";
+export declare function networkEnv(hostname?: string): Record<string, string>;
+export declare function missingTransport(): RealmTransport;
+export declare function memoryCaStore(): CaStore;
+export declare function caStore(name: string | false): CaStore;
+export declare function packageTlsEngine(fs: KernelFs, modules: string): () => Promise<TlsEngineModule>;
+export interface NetworkOptions {
+    transport?: RealmTransport;
+    engine: () => Promise<TlsEngine>;
+    ca: () => Promise<RealmCa>;
+    now?: () => number;
+}
+export declare function kernelCa(store: CaStore): () => Promise<RealmCa>;
+export declare function kernelTlsEngine(load: () => Promise<TlsEngineModule>): () => Promise<TlsEngine>;
+export declare const CA_BUNDLE_MAX = 16;
+export interface LockLike {
+    request<T>(name: string, run: () => Promise<T>): Promise<T>;
+}
+export declare function writeCaFile(fs: KernelFs, ca: () => Promise<RealmCa>, locks?: LockLike | undefined): Promise<void>;
+export declare function enableNetwork(net: LoopbackNet, options: NetworkOptions): () => RealmProxy | undefined;

package/dist/types/kernel/net/proxy-service.d.ts

@@ -0,0 +1,70 @@
+import type { KernelSocket, LoopbackNet } from '../socket.js';
+import { type ByteSource, Incoming, type RequestHead } from './http1.js';
+import type { HeaderList, RealmTransport } from './transport.js';
+export declare const NO_WEBSOCKET = "WebSocket not supported by this transport (fetchTransport needs { webSocket: true })";
+export declare const REALM_PROXY_PORT = 3128;
+export interface ProxyLimits {
+    maxConnections: number;
+    maxHead: number;
+    idleMs: number;
+    bodyBudget: number;
+    closeWaitMs: number;
+}
+export interface TunnelTarget {
+    host: string;
+    port: number;
+}
+export interface HttpSink {
+    write(bytes: Uint8Array, signal?: AbortSignal): Promise<unknown>;
+}
+export type ServeHttp = (source: ByteSource, sink: HttpSink, origin: string) => Promise<void>;
+export type TunnelHandler = (conn: KernelSocket, incoming: Incoming, target: TunnelTarget, signal: AbortSignal, serveHttp: ServeHttp) => Promise<void>;
+export interface RealmProxyOptions {
+    net: LoopbackNet;
+    transport: RealmTransport;
+    host?: string;
+    port?: number;
+    tunnel?: TunnelHandler;
+    tunnelReady?: () => Promise<void>;
+    limits?: Partial<ProxyLimits>;
+}
+export declare function canonicalHost(host: string): string | undefined;
+export declare function isLoopbackHost(hostname: string): boolean;
+export declare function forwardRequestHeaders(headers: HeaderList): HeaderList;
+export declare function forwardResponseHeaders(headers: HeaderList, opts: {
+    encodedBodies: boolean;
+    bodiless: boolean;
+}): Array<readonly [string, string]>;
+export declare function tunnelRequestUrl(req: RequestHead, origin: string): string;
+export declare function requestUrl(req: RequestHead): string;
+export declare function tunnelTarget(req: RequestHead): TunnelTarget;
+export declare function watchHangup(conn: KernelSocket, abort: AbortController, until: AbortSignal): Promise<void>;
+export declare function webSocketTarget(req: RequestHead): RequestHead;
+export declare class RealmProxy {
+    private readonly options;
+    private readonly listener;
+    private readonly stop;
+    private readonly limits;
+    private readonly slots;
+    private readonly bodies;
+    private readonly connections;
+    private warnedWebSocket;
+    readonly closed: Promise<void>;
+    readonly port: number;
+    constructor(options: RealmProxyOptions);
+    get stopped(): boolean;
+    close(): void;
+    private acceptLoop;
+    private serve;
+    private requests;
+    private refuse;
+    private exchange;
+    private cap;
+    private expectContinue;
+    private upstream;
+    private relay;
+    private connect;
+    private tunnelReady;
+    private websocket;
+    private bridge;
+}

package/dist/types/kernel/net/realm-ca.d.ts

@@ -0,0 +1,28 @@
+import { type DistinguishedName } from './x509.js';
+export interface CaRecord {
+    key: CryptoKey;
+    cert: Uint8Array;
+    spki: Uint8Array;
+    notAfter: number;
+    name: DistinguishedName;
+}
+export interface CaStore {
+    get(owner: string): Promise<CaRecord | undefined>;
+    swap(owner: string, expected: CaRecord | undefined, record: CaRecord): Promise<CaRecord>;
+}
+export declare function winner(current: CaRecord | undefined, expected: CaRecord | undefined, record: CaRecord): CaRecord | undefined;
+export declare const LEAF_LIFETIME: number;
+export declare function indexedDbCaStore(dbName?: string): CaStore;
+export declare class LeafNameError extends Error {
+}
+export declare function validLeafName(host: string): boolean;
+export declare class RealmCa {
+    private readonly record;
+    private constructor();
+    static open(owner: string, store: CaStore, now?: number): Promise<RealmCa>;
+    private static create;
+    get cert(): Uint8Array;
+    get pem(): string;
+    issue(host: string, spki: Uint8Array, now?: number): Promise<Uint8Array>;
+}
+export declare function realmCa(owner: string, store: CaStore): Promise<RealmCa>;

package/dist/types/kernel/net/redirect-hops.d.ts

@@ -0,0 +1,5 @@
+import type { RealmTransport } from './transport.js';
+export declare const HELD_MS = 30000;
+export declare const HELD_MAX = 64;
+export declare const HELD_PER_OWNER = 8;
+export declare function replayingHops(inner: RealmTransport, heldMs?: number): RealmTransport;

package/dist/types/kernel/net/remote-transport.d.ts

@@ -0,0 +1,98 @@
+import type { HeaderList, RealmRedirectHop, RealmTransport, RealmTransportRequest, RealmTransportResponse, RealmTransportTraits, RealmWebSocket, RealmWebSocketMessage, RealmWebSocketRequest } from './transport.js';
+export type TransportCall = {
+    net: 'fetch';
+    nid: number;
+    url: string;
+    method: string;
+    headers: HeaderList;
+    body?: Uint8Array;
+} | {
+    net: 'read';
+    nid: number;
+} | {
+    net: 'cancel';
+    nid: number;
+} | {
+    net: 'ws-open';
+    nid: number;
+    url: string;
+    protocols: string[];
+    headers: HeaderList;
+} | {
+    net: 'ws-send';
+    nid: number;
+    data: RealmWebSocketMessage;
+} | {
+    net: 'ws-close';
+    nid: number;
+    code?: number;
+    reason?: string;
+} | {
+    net: 'ws-consumed';
+    nid: number;
+    n: number;
+};
+export type TransportReply = {
+    net: 'head';
+    nid: number;
+    status: number;
+    statusText: string;
+    headers: HeaderList;
+    url?: string;
+    redirected?: boolean;
+    redirects?: readonly RealmRedirectHop[];
+} | {
+    net: 'chunk';
+    nid: number;
+    bytes: Uint8Array;
+} | {
+    net: 'end';
+    nid: number;
+} | {
+    net: 'error';
+    nid: number;
+    message: string;
+    status?: number;
+    code?: string;
+} | {
+    net: 'ws-opened';
+    nid: number;
+    protocol: string;
+} | {
+    net: 'ws-message';
+    nid: number;
+    data: RealmWebSocketMessage;
+} | {
+    net: 'ws-acked';
+    nid: number;
+    n: number;
+} | {
+    net: 'ws-closed';
+    nid: number;
+    code: number;
+    reason: string;
+};
+export interface TransportPort {
+    postMessage(message: TransportCall): void;
+}
+export declare class TransportError extends Error {
+    readonly status: number | undefined;
+    readonly code: string | undefined;
+    constructor(message: string, status?: number, code?: string);
+}
+export declare class RemoteTransport implements RealmTransport {
+    traits: RealmTransportTraits;
+    private readonly port;
+    private readonly waiting;
+    private nextId;
+    private readonly sockets;
+    private failure;
+    constructor(port: TransportPort, traits: RealmTransportTraits);
+    receive(reply: TransportReply): void;
+    private toSocket;
+    fail(error: Error): void;
+    private ask;
+    private cancel;
+    fetch(request: RealmTransportRequest): Promise<RealmTransportResponse>;
+    websocket(request: RealmWebSocketRequest): Promise<RealmWebSocket>;
+}

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

@@ -0,0 +1,29 @@
+import { type Routes } from './routes.js';
+import { type NetworkUplink, type ResolveFamily } from './uplink.js';
+export declare const RESOLVE_TTL_MAX = 60;
+export declare const RESOLVE_TIMEOUT_MS = 10000;
+export declare const RESOLVE_CACHE_MAX = 256;
+export interface ResolverOptions {
+    uplink?: NetworkUplink | undefined;
+    routes: Routes;
+    now?: () => number;
+    timeoutMs?: number;
+    log?: (message: string) => void;
+    hostname?: string;
+}
+export declare function hostsEntry(name: string, own?: readonly string[]): string | undefined;
+export declare class Resolver {
+    private readonly uplink;
+    private readonly routes;
+    private readonly now;
+    private readonly timeoutMs;
+    private readonly log;
+    private readonly own;
+    private readonly cache;
+    private readonly pending;
+    constructor(options: ResolverOptions);
+    resolve(name: string, family: ResolveFamily, blocking?: () => AbortSignal): Promise<string[]>;
+    private lookup;
+    private usable;
+    private remember;
+}

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

@@ -0,0 +1,15 @@
+export interface RouteTable {
+    prefixes: readonly string[];
+    exit: boolean;
+}
+export type Destination = 'loopback' | 'host' | 'reserved' | 'uplink' | 'unreachable';
+export declare function ipv4Bytes(text: string): number[] | undefined;
+export declare function ipv6Groups(text: string): number[] | undefined;
+export declare class Routes {
+    private table;
+    private exit;
+    readonly ipv6: boolean;
+    constructor(ipv6?: boolean);
+    set(table: RouteTable): void;
+    classify(host: string): Destination;
+}

package/dist/types/kernel/net/tls-engine.d.ts

@@ -0,0 +1,46 @@
+type TlsExport = 'malloc' | 'free' | 'tls_last_error' | 'tls_strerror' | 'tls_leaf_new' | 'tls_leaf_spki' | 'tls_leaf_add_cert' | 'tls_leaf_free' | 'tls_session_new' | 'tls_feed' | 'tls_feed_eof' | 'tls_in_room' | 'tls_read' | 'tls_write' | 'tls_out_size' | 'tls_out_take' | 'tls_close' | 'tls_alpn_http11' | 'tls_session_free';
+export type TlsEngineModule = {
+    readonly HEAPU8: Uint8Array;
+} & {
+    readonly [K in TlsExport as `_${K}`]: (...args: number[]) => number;
+};
+export declare class TlsError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export declare class TlsEngine {
+    private readonly m;
+    private readonly scratch;
+    constructor(m: TlsEngineModule);
+    private put;
+    private taken;
+    error(code: number, what: string): TlsError;
+    leaf(): TlsLeaf;
+    session(leaf: TlsLeaf, host: string): TlsSession;
+    withBytes<T>(bytes: Uint8Array, fn: (ptr: number) => T): T;
+    intoScratch(fn: (ptr: number, max: number) => number): number | Uint8Array;
+}
+export declare class TlsLeaf {
+    private readonly engine;
+    private readonly m;
+    readonly ptr: number;
+    constructor(engine: TlsEngine, m: TlsEngineModule, ptr: number);
+    spki(): Uint8Array;
+    addCert(der: Uint8Array): void;
+    release(): void;
+}
+export declare class TlsSession {
+    private readonly engine;
+    private readonly m;
+    private readonly ptr;
+    constructor(engine: TlsEngine, m: TlsEngineModule, ptr: number);
+    feed(bytes: Uint8Array): number;
+    feedEnd(): void;
+    read(): Uint8Array | 'more' | 'eof';
+    write(bytes: Uint8Array): number;
+    take(): Uint8Array;
+    close(): void;
+    free(): void;
+}
+export declare function loadTlsEngine(load: () => Promise<TlsEngineModule>): Promise<TlsEngine>;
+export {};

package/dist/types/kernel/net/tls-tunnel.d.ts

@@ -0,0 +1,35 @@
+import type { KernelSocket } from '../socket.js';
+import type { ByteSource } from './http1.js';
+import type { HttpSink, TunnelHandler, TunnelTarget } from './proxy-service.js';
+import { type RealmCa } from './realm-ca.js';
+import type { TlsEngine, TlsSession } from './tls-engine.js';
+export declare class TlsStream implements ByteSource, HttpSink {
+    private readonly session;
+    private readonly cipherIn;
+    private readonly cipherOut;
+    private pending;
+    private ended;
+    constructor(session: TlsSession, cipherIn: ByteSource, cipherOut: KernelSocket);
+    private flush;
+    private feedPending;
+    read(_max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    write(bytes: Uint8Array, signal?: AbortSignal): Promise<number>;
+    close(signal?: AbortSignal): Promise<void>;
+}
+export interface TlsTerminatorOptions {
+    ca: () => Promise<RealmCa>;
+    engine: () => Promise<TlsEngine>;
+    now?: () => number;
+}
+export declare class TlsTerminator {
+    private readonly options;
+    private readonly leaves;
+    private readonly now;
+    constructor(options: TlsTerminatorOptions);
+    private leafFor;
+    private drop;
+    private issue;
+    close(): Promise<void>;
+    readonly handler: TunnelHandler;
+}
+export declare function authority(target: TunnelTarget): string;

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

@@ -0,0 +1,64 @@
+export type HeaderList = ReadonlyArray<readonly [name: string, value: string]>;
+export interface RealmTransportRequest {
+    url: string;
+    method: string;
+    headers: HeaderList;
+    body?: Uint8Array;
+    signal: AbortSignal;
+}
+export interface RealmRedirectHop {
+    status: number;
+    url: string;
+    headers: HeaderList;
+}
+export interface RealmTransportResponse {
+    url?: string;
+    redirected?: boolean;
+    redirects?: readonly RealmRedirectHop[];
+    status: number;
+    statusText: string;
+    headers: HeaderList;
+    body: AsyncIterable<Uint8Array>;
+    cancel(): Promise<void>;
+}
+export interface RealmTransportExit {
+    kind: 'local' | 'remote' | 'tailnet' | (string & {});
+    caps: readonly string[];
+    [detail: string]: unknown;
+}
+export interface RealmTransportTraits {
+    manualRedirects: boolean;
+    encodedBodies: boolean;
+    maxRequestBody: number;
+    crossOrigin?: 'cors' | 'any';
+    unavailable?: true;
+    websocket?: true;
+    redirectHops?: true;
+    exit?: RealmTransportExit;
+    [trait: string]: unknown;
+}
+export interface RealmWebSocketRequest {
+    url: string;
+    protocols: string[];
+    headers: HeaderList;
+    signal: AbortSignal;
+}
+export interface RealmWebSocketClose {
+    code: number;
+    reason: string;
+    wasClean?: boolean;
+}
+export type RealmWebSocketMessage = string | Uint8Array;
+export interface RealmWebSocket {
+    readonly protocol: string;
+    readonly buffered: number;
+    send(data: RealmWebSocketMessage): void;
+    readonly messages: AsyncIterable<RealmWebSocketMessage>;
+    close(code?: number, reason?: string): void;
+    readonly closed: Promise<RealmWebSocketClose>;
+}
+export interface RealmTransport {
+    readonly traits: RealmTransportTraits;
+    fetch(request: RealmTransportRequest, owner?: number): Promise<RealmTransportResponse>;
+    websocket?(request: RealmWebSocketRequest): Promise<RealmWebSocket>;
+}

package/dist/types/kernel/net/uplink-socket.d.ts

@@ -0,0 +1,11 @@
+import { KernelPipe } from '../pipe.js';
+import type { UplinkConn } from './uplink.js';
+export interface UplinkLink {
+    rx: KernelPipe;
+    tx: KernelPipe;
+}
+export declare function hostPort(text: string): {
+    host: string;
+    port: number;
+} | undefined;
+export declare function uplinkLink(conn: UplinkConn, onReset: () => void): UplinkLink;