@ai-ecoverse/slicc-kernel 1.102.5 → 1.103.0

package/dist/process-worker.js

@@ -2484,7 +2484,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.102.5" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.103.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });

package/dist/types/body-idle.d.ts

@@ -0,0 +1,3 @@
+export declare const BODY_IDLE_MS: number;
+export declare function idleFailure(ms: number): Error;
+export declare function readWithin<T>(reader: ReadableStreamDefaultReader<T>, ms: number): Promise<ReadableStreamReadResult<T>>;

package/dist/types/bytes.d.ts

@@ -0,0 +1 @@
+export declare function fresh(bytes: Uint8Array, start?: number, end?: number): Uint8Array;

package/dist/types/cdp/facade.d.ts

@@ -0,0 +1,27 @@
+import type { LoopbackNet } from '../kernel/socket.js';
+import type { CdpHosts } from './hosts.js';
+export interface CdpFacadeOptions {
+    net: LoopbackNet;
+    hosts: CdpHosts;
+    port?: number;
+    maxMessage?: number;
+    closeWaitMs?: number;
+    listTimeout?: number;
+}
+export declare class CdpFacade {
+    private readonly options;
+    private readonly listener;
+    private readonly stop;
+    private readonly connections;
+    readonly closed: Promise<void>;
+    constructor(options: CdpFacadeOptions);
+    close(): void;
+    private acceptLoop;
+    private serve;
+    private write;
+    private route;
+    private list;
+    private host;
+    private upgrade;
+}
+export declare function enableCdp(net: LoopbackNet, hosts: CdpHosts): () => CdpFacade | undefined;

package/dist/types/cdp/hosts.d.ts

@@ -0,0 +1,14 @@
+import { type CdpConnection, type CdpHook, type CdpRequest } from './types.js';
+export declare class CdpHosts {
+    private readonly embedder;
+    private readonly clients;
+    private closed;
+    readonly path: string;
+    readonly url: string;
+    constructor(hook?: CdpHook);
+    register(hook: CdpHook, runtime?: string): () => void;
+    private pick;
+    available(runtime?: string): boolean;
+    connect(request: CdpRequest): Promise<CdpConnection>;
+    close(): void;
+}

package/dist/types/cdp/port.d.ts

@@ -0,0 +1,24 @@
+import type { CdpHook, CdpRequest } from './types.js';
+export interface CdpPortLike {
+    postMessage(message: unknown): void;
+    addEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+    start?(): void;
+    close(): void;
+}
+export type CdpWire = {
+    open: true;
+} | {
+    error: string;
+} | {
+    m: string;
+} | {
+    close: string | null;
+};
+export interface CdpOpen {
+    cdpOpen: CdpRequest & {
+        registration?: number;
+    };
+    port: CdpPortLike;
+}
+export declare function serveCdpPort(port: CdpPortLike, hook: CdpHook, request: CdpRequest, onDone?: () => void): () => void;
+export declare function portCdpHook(ask: (request: CdpRequest, port: CdpPortLike) => void, gone?: Promise<unknown>): CdpHook;

package/dist/types/cdp/types.d.ts

@@ -0,0 +1,12 @@
+export interface CdpConnection {
+    send(message: string): void;
+    onmessage: ((message: string) => void) | null;
+    onclose: ((reason?: string) => void) | null;
+    close(): void;
+}
+export interface CdpRequest {
+    runtime?: string;
+}
+export type CdpHook = (request: CdpRequest) => Promise<CdpConnection>;
+export declare const CDP_PORT = 9222;
+export declare const NO_CDP_HOST = "slicc-kernel: no CDP host is attached (createKernel({ cdp }) or client.serveCdp)";

package/dist/types/cdp/websocket.d.ts

@@ -0,0 +1,61 @@
+import { type Incoming } from '../kernel/net/http1.js';
+import type { HeaderList } from '../kernel/net/transport.js';
+export declare const MAX_MESSAGE: number;
+export declare const CLOSE: {
+    readonly normal: 1000;
+    readonly protocol: 1002;
+    readonly unsupported: 1003;
+    readonly invalid: 1007;
+    readonly tooBig: 1009;
+    readonly error: 1011;
+};
+export declare const OP_TEXT = 1;
+export declare const OP_BINARY = 2;
+export interface Sink {
+    write(bytes: Uint8Array, signal?: AbortSignal): Promise<unknown>;
+}
+export type WsEvent = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'ping';
+    payload: Uint8Array;
+} | {
+    kind: 'close';
+    code: number;
+    reason: string;
+};
+export type WsBinaryEvent = {
+    kind: 'binary';
+    bytes: Uint8Array;
+};
+export declare class WsError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export declare function sendableCode(code: number): boolean;
+export declare function acceptKey(headers: HeaderList): Promise<string>;
+export declare function acceptFor(key: string): Promise<string>;
+export declare function isUpgrade(headers: HeaderList): boolean;
+export declare function frame(opcode: number, payload: Uint8Array): Uint8Array;
+export declare function clientFrame(opcode: number, payload: Uint8Array): Uint8Array;
+export declare function closeFrame(code: number, reason?: string): Uint8Array;
+export declare function pongFrame(payload: Uint8Array): Uint8Array;
+export declare class WsReader<Binary extends boolean = false> {
+    private readonly incoming;
+    private readonly max;
+    private parts;
+    private size;
+    private continuing;
+    private binaryMessage;
+    private readonly binary;
+    private readonly fromServer;
+    constructor(incoming: Incoming, max?: number, binary?: Binary, fromServer?: boolean);
+    next(signal?: AbortSignal): Promise<WsEvent | (Binary extends true ? WsBinaryEvent : never) | null>;
+    private masking;
+    private data;
+    private payload;
+    private length;
+    private take;
+}
+export declare function switchingHead(accept: string, protocol?: string): Uint8Array;

package/dist/types/client/attach.d.ts

@@ -0,0 +1,132 @@
+import type { CdpHook } from '../cdp/types.js';
+import type { FacadeHook } from '../facade/types.js';
+import type { FsStat, UsersMode } from '../fs/types.js';
+import type { WatchChange } from '../fs/watch.js';
+import type { RealmTransport, RealmTransportRequest, RealmTransportResponse, RealmTransportTraits } from '../kernel/net/transport.js';
+import type { MountEntry, MountSpec } from '../mount/mount-fs.js';
+import { type DialledSocket, type DialOptions } from './dial-stream.js';
+import { type LoopbackFetchOptions } from './loopback-fetch.js';
+import { type LockManagerLike, type MessagePortLike, type ProcessEntry } from './protocol.js';
+export type { WatchChange } from '../fs/watch.js';
+export type { ProcessEntry } from './protocol.js';
+export declare class KernelGoneError extends Error {
+    constructor(message?: string);
+}
+export declare class KernelCallError extends Error {
+    readonly code: string | undefined;
+    constructor(message: string, code?: string);
+}
+export interface AttachOptions {
+    timeoutMs?: number;
+    locks?: LockManagerLike | null;
+}
+export interface SpawnOptions {
+    cwd?: string;
+    user?: string | number;
+    env?: Record<string, string>;
+    stdin?: string | Uint8Array;
+    group?: 'new';
+    pgid?: number;
+    onStdout?: (bytes: Uint8Array) => void;
+    onStderr?: (bytes: Uint8Array) => void;
+}
+export interface ClientEnded {
+    status: number;
+    signal?: string;
+}
+export interface SpawnedProcess {
+    readonly pid: number;
+    readonly pgid: number;
+    readonly exited: Promise<number>;
+    readonly ended: Promise<ClientEnded>;
+    signal(name?: string): Promise<void>;
+}
+export interface ClientRunOptions {
+    cwd?: string;
+    user?: string | number;
+    env?: Record<string, string>;
+    stdin?: string | Uint8Array;
+    onStdout?: (text: string) => void;
+    onStderr?: (text: string) => void;
+}
+export interface ClientRunResult {
+    pid: number;
+    status: number;
+    signal?: string;
+    stdout: string;
+    stderr: string;
+}
+export interface ClientTerminalOptions {
+    cwd?: string;
+    user?: string | number;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    onData?: (bytes: Uint8Array) => void;
+}
+export interface ClientTerminal {
+    readonly pid: number;
+    readonly exited: Promise<number>;
+    readonly ended: Promise<ClientEnded>;
+    onData: ((bytes: Uint8Array) => void) | null;
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    signal(name: string): void;
+    close(): void;
+}
+export interface ClientFs {
+    readFile(path: string): Promise<Uint8Array>;
+    readText(path: string): Promise<string>;
+    writeFile(path: string, data: string | Uint8Array): Promise<void>;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    readdir(path: string): Promise<string[]>;
+    mkdir(path: string): Promise<void>;
+    rm(path: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    realpath(path: string): Promise<string>;
+    symlink(target: string, path: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+    exists(path: string): Promise<boolean>;
+    watch(paths: string[], options: {
+        recursive?: boolean;
+    }, onChange: (change: WatchChange) => void): Promise<{
+        close(): void;
+    }>;
+}
+export type ClientFetchRequest = Omit<RealmTransportRequest, 'signal'> & {
+    signal?: AbortSignal;
+};
+export interface KernelClient {
+    readonly protocol: readonly [number, number];
+    readonly transport: RealmTransport;
+    readonly users: UsersMode;
+    readonly closed: Promise<Error>;
+    spawn(argv: string[], options?: SpawnOptions): Promise<SpawnedProcess>;
+    run(argv: string[], options?: ClientRunOptions): Promise<ClientRunResult>;
+    openTerminal(argv: string[], options?: ClientTerminalOptions): Promise<ClientTerminal>;
+    ps(): Promise<ProcessEntry[]>;
+    mount(spec: MountSpec): Promise<MountEntry>;
+    umount(target: string): Promise<void>;
+    mounts(): Promise<MountEntry[]>;
+    kill(pid: number, signal?: string): Promise<void>;
+    fetch(request: ClientFetchRequest): Promise<RealmTransportResponse>;
+    dial(options: DialOptions): Promise<DialledSocket>;
+    loopbackFetch(input: RequestInfo | URL, options: LoopbackFetchOptions): Promise<Response>;
+    readonly fs: ClientFs;
+    serveCdp(hook: CdpHook, options?: {
+        runtime?: string;
+    }): Promise<{
+        close(): void;
+    }>;
+    serveFacade(name: string, hook: FacadeHook): Promise<{
+        close(): void;
+    }>;
+    onTraits(listener: (traits: RealmTransportTraits) => void): () => void;
+    close(options?: {
+        kill?: boolean;
+    }): Promise<void>;
+}
+export declare function attachKernel(port: MessagePortLike, options?: AttachOptions): Promise<KernelClient>;

package/dist/types/client/dial-stream.d.ts

@@ -0,0 +1,23 @@
+export interface DialledSocket {
+    readable: ReadableStream<Uint8Array>;
+    writable: WritableStream<Uint8Array>;
+    close(): void;
+}
+export interface DialOptions {
+    port: number;
+    host?: string;
+}
+interface StreamPort {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+    start?(): void;
+    close(): void;
+}
+export interface DialHandle extends DialledSocket {
+    fail(error: Error): void;
+}
+export declare function errorWithCode(message: string): Error & {
+    code?: string;
+};
+export declare function dialStream(port: StreamPort, onClose?: () => void): DialHandle;
+export {};

package/dist/types/client/loopback-fetch.d.ts

@@ -0,0 +1,5 @@
+import { type DialledSocket, type DialOptions } from './dial-stream.js';
+export interface LoopbackFetchOptions extends DialOptions {
+    signal?: AbortSignal;
+}
+export declare function loopbackFetch(dial: (options: DialOptions) => Promise<DialledSocket>, input: RequestInfo | URL, options: LoopbackFetchOptions): Promise<Response>;

package/dist/types/client/protocol.d.ts

@@ -0,0 +1,153 @@
+import type { UsersMode } from '../fs/types.js';
+import type { WatchChange } from '../fs/watch.js';
+import type { TransportCall, TransportReply } from '../kernel/net/remote-transport.js';
+import type { RealmTransportTraits } from '../kernel/net/transport.js';
+import type { MountSpec } from '../mount/mount-fs.js';
+export declare const PROTOCOL: readonly [number, number];
+export interface ClientHello {
+    protocol: readonly [number, number];
+    lock?: string;
+}
+export interface KernelHello {
+    protocol: readonly [number, number];
+    lock?: string;
+    traits?: RealmTransportTraits;
+    users?: UsersMode;
+    error?: string;
+}
+export interface SpawnRequestOptions {
+    cwd?: string;
+    user?: string | number;
+    env?: Record<string, string>;
+    stdin?: Uint8Array;
+    pgid?: number;
+}
+export interface TerminalRequestOptions {
+    cwd?: string;
+    user?: string | number;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+}
+export type TerminalAction = {
+    action: 'write';
+    bytes: Uint8Array;
+} | {
+    action: 'resize';
+    cols: number;
+    rows: number;
+} | {
+    action: 'signal';
+    signal: string;
+} | {
+    action: 'close';
+};
+export declare const FS_METHODS: readonly ['readFile', 'writeFile', 'stat', 'lstat', 'readdir', 'mkdir', 'rm', 'rename', 'realpath', 'symlink', 'readlink', 'exists'];
+export type FsMethod = (typeof FS_METHODS)[number];
+export type ClientCall = {
+    op: 'spawn';
+    argv: string[];
+    options: SpawnRequestOptions;
+} | {
+    op: 'open-terminal';
+    argv: string[];
+    options: TerminalRequestOptions;
+} | ({
+    op: 'terminal';
+    terminal: number;
+} & TerminalAction) | {
+    op: 'kill';
+    pid: number;
+    signal: string;
+} | {
+    op: 'ps';
+} | {
+    op: 'fs';
+    method: FsMethod;
+    args: unknown[];
+} | {
+    op: 'watch';
+    paths: string[];
+    recursive: boolean;
+} | {
+    op: 'unwatch';
+    watch: number;
+} | {
+    op: 'mount';
+    spec: MountSpec;
+} | {
+    op: 'umount';
+    target: string;
+} | {
+    op: 'mounts';
+} | {
+    op: 'dial';
+    port: number;
+    host?: string;
+} | {
+    op: 'serve-cdp';
+    runtime?: string;
+} | {
+    op: 'unserve-cdp';
+    registration: number;
+} | {
+    op: 'serve-facade';
+    name: string;
+} | {
+    op: 'unserve-facade';
+    registration: number;
+} | {
+    op: 'detach';
+    kill?: boolean;
+};
+export type ClientRequest = ClientCall & {
+    id: number;
+};
+export interface ClientReply {
+    id: number;
+    result?: unknown;
+    error?: string;
+    code?: string;
+    fd?: 1 | 2;
+    bytes?: Uint8Array;
+    started?: number;
+    signal?: string;
+}
+export type ClientMessage = {
+    hello: ClientHello;
+} | ClientRequest | TransportCall;
+export interface WatchEvent {
+    watch: number;
+    change: WatchChange;
+}
+export type KernelMessage = {
+    hello: KernelHello;
+} | ClientReply | WatchEvent | TransportReply;
+export interface ProcessEntry {
+    pid: number;
+    ppid: number;
+    pgid: number;
+    sid: number;
+    argv: string[];
+    tty: string | null;
+    started: number;
+    state: 'S' | 'T' | 'Z';
+    memory: number;
+    rss?: number;
+    utime?: number;
+    stime?: number;
+    uid?: number;
+    gid?: number;
+    tag?: string;
+}
+export interface MessagePortLike {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message' | 'close', handler: (event: MessageEvent) => void): void;
+    start?(): void;
+    close?(): void;
+}
+export interface LockManagerLike {
+    request(name: string, callback: () => Promise<unknown> | unknown): Promise<unknown>;
+}
+export declare function locksOf(scope?: object): LockManagerLike | undefined;
+export declare function versionError(theirs: unknown): string | undefined;

package/dist/types/client/serve-client.d.ts

@@ -0,0 +1,18 @@
+import type { RealmTransport } from '../kernel/net/transport.js';
+import type { Launcher } from '../launcher.js';
+import { type LockManagerLike, type MessagePortLike } from './protocol.js';
+export interface ClientHost {
+    scope?: 'transport';
+    launcher: () => Promise<Launcher>;
+    transport?: () => RealmTransport;
+    locks?: LockManagerLike;
+    lock?: string;
+    signal?: (name: string) => number;
+    user?: string | number;
+    tag?: string;
+}
+export interface ServedClient {
+    detach(kill?: boolean): void;
+    readonly closed: Promise<void>;
+}
+export declare function serveClient(port: MessagePortLike, host: ClientHost): ServedClient;

package/dist/types/clipboard-relay.d.ts

@@ -0,0 +1,25 @@
+import { type ClipboardHook, type ClipboardStamp } from './kernel/clipboard.js';
+export interface ClipboardPort {
+    postMessage(message: unknown): void;
+}
+export interface ClipboardAsk {
+    id: number;
+    op: 'read' | 'write';
+    text?: string;
+    stamp: ClipboardStamp;
+}
+export interface ClipboardReply {
+    id: number;
+    text?: string;
+    error?: {
+        name: string;
+        message: string;
+    };
+}
+export declare function clipboardAsker(port: ClipboardPort): {
+    hook: ClipboardHook;
+    answer(reply: ClipboardReply): void;
+};
+export declare function clipboardAnswerer(port: ClipboardPort, hook: ClipboardHook | undefined): {
+    handle(data: unknown): boolean;
+};

package/dist/types/commands.d.ts

@@ -0,0 +1,38 @@
+import { type KernelFs } from './fs/types.js';
+export type Abi = 'emscripten' | 'wasi' | 'js';
+export interface Command {
+    name: string;
+    abi: Abi;
+    glue: string;
+    wasm: string;
+    argv0: string;
+    argv0Path?: boolean;
+    argv0Fixed?: true;
+    preopenRoot?: boolean;
+    args?: string[];
+    env?: Record<string, string>;
+    unset?: string[];
+    script?: string;
+    bin?: true;
+    imports?: string;
+}
+interface Manifest {
+    name?: unknown;
+    bin?: unknown;
+    slicc?: {
+        abi?: unknown;
+        commands?: unknown;
+        env?: unknown;
+        filesystems?: unknown;
+        binfmt?: unknown;
+        replaces?: unknown;
+    };
+}
+export declare function commandsOf(pkg: string, manifest: Manifest): Command[];
+export declare function pnpmGlobalRoots(fs: KernelFs, home: string): Promise<string[]>;
+export declare function scanCommands(fs: KernelFs, modules: string | (string | string[])[], binsFrom?: number): Promise<Map<string, Command>>;
+export declare function scanFilesystems(fs: KernelFs, modules: string | string[]): Promise<Map<string, string>>;
+export declare function scanBinfmts(fs: KernelFs, modules: string | string[], warn?: (message: string) => void, owners?: Map<string, string>): Promise<Map<string, string>>;
+export declare function binfmtSuffix(binfmts: ReadonlyMap<string, string>, path: string): string | undefined;
+export declare function binfmtOf(binfmts: ReadonlyMap<string, string>, path: string): string | undefined;
+export {};

package/dist/types/cron/clock.d.ts

@@ -0,0 +1,13 @@
+export interface CronClock {
+    now(): number;
+    readonly utc?: boolean;
+    sleep(until: number, signal: AbortSignal): Promise<void>;
+}
+export declare const systemCronClock: CronClock;
+export interface FakeCronClock extends CronClock {
+    set(ms: number): void;
+    advance(ms: number): void;
+    flush(): Promise<void>;
+    readonly sleepers: number;
+}
+export declare function fakeCronClock(start?: number, utc?: boolean): FakeCronClock;

package/dist/types/driver.d.ts

@@ -0,0 +1,3 @@
+export { type DriverPort, type FilesystemHandlers, fsError, type OpenFlags, type ServedFilesystem, serveFilesystem, } from './mount/driver.js';
+export type { DriverEnv, DriverFactory } from './mount/host.js';
+export type { DriverAttr, DriverCapabilities, DriverEntry, DriverStatfs, MountRequestInfo, } from './mount/protocol.js';

package/dist/types/facade/hosts.d.ts

@@ -0,0 +1,12 @@
+import type { LoopbackNet } from '../kernel/socket.js';
+import { type FacadeHook, type FacadeSpecs } from './types.js';
+export declare const FACADE_MAX_PENDING: number;
+export declare const FACADE_FLOODED = "slicc-kernel: more than 16777216 bytes are waiting for the program to read";
+export declare class FacadeHosts {
+    private readonly facades;
+    constructor(specs?: FacadeSpecs);
+    env(): Record<string, string>;
+    enable(net: LoopbackNet): void;
+    register(name: string, hook: FacadeHook): () => void;
+    private serve;
+}

package/dist/types/facade/port.d.ts

@@ -0,0 +1,16 @@
+import type { FacadeHook, FacadeOpenRequest } from './types.js';
+export interface FacadePortLike {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+    start?(): void;
+    close(): void;
+}
+export interface FacadeOpen {
+    facadeOpen: FacadeOpenRequest & {
+        registration?: number;
+    };
+    port: FacadePortLike;
+}
+export declare const FACADE_GONE = "the facade host is gone";
+export declare function serveFacadePort(port: FacadePortLike, hook: FacadeHook, { name, stamp }: FacadeOpenRequest, onDone?: () => void): () => void;
+export declare function portFacadeHook(ask: (request: FacadeOpenRequest, port: FacadePortLike) => void, gone?: Promise<unknown>): FacadeHook;

package/dist/types/facade/types.d.ts

@@ -0,0 +1,23 @@
+import type { ConnectorStamp } from '../kernel/socket.js';
+export interface FacadeConnection {
+    send(bytes: Uint8Array): void;
+    onmessage: ((bytes: Uint8Array) => void) | null;
+    onclose: ((reason?: string) => void) | null;
+    close(reason?: string): void;
+}
+export interface FacadeInfo {
+    name: string;
+}
+export type FacadeHook = (stamp: ConnectorStamp, info: FacadeInfo) => FacadeConnection | Promise<FacadeConnection>;
+export interface FacadeSpec {
+    port: number;
+    hook?: FacadeHook;
+}
+export type FacadeSpecs = Readonly<Record<string, FacadeSpec>>;
+export interface FacadeOpenRequest {
+    name: string;
+    stamp: ConnectorStamp;
+}
+export declare const FACADE_NAME: RegExp;
+export declare function facadeEnvName(name: string): string;
+export declare function facadeUrl(port: number): string;

package/dist/types/fs/access.d.ts

@@ -0,0 +1,29 @@
+import type { Cred } from '../kernel/cred.js';
+import { type FsStat, type KernelFs, type Perm } from './types.js';
+export type { Perm };
+export declare const R_OK = 4;
+export declare const W_OK = 2;
+export declare const X_OK = 1;
+export interface Walked {
+    path: string;
+    perm: Perm | undefined;
+    denied?: string;
+    missing?: boolean;
+    link?: true;
+}
+export declare function permOf(st: FsStat, link?: string): Perm;
+export declare function permits(cred: Readonly<Cred>, perm: Perm, want: number, directory?: boolean): boolean;
+export declare function sticky(cred: Readonly<Cred>, dir: Perm, entry: Perm | undefined): boolean;
+export declare function ancestryOf(fs: KernelFs, path: string): Promise<Array<Perm | undefined>>;
+export declare function trustedLink(perm: Perm, links: number | undefined): boolean;
+export declare function walk(fs: KernelFs, cred: Readonly<Cred>, path: string, follow: boolean, links?: number): Promise<Walked>;
+export declare function present(fs: KernelFs, path: string, directory: boolean): Promise<boolean>;
+export interface AccessOptions {
+    follow?: boolean;
+    directory?: boolean;
+    links?: number | undefined;
+}
+export declare function access(fs: KernelFs, cred: Readonly<Cred>, path: string, want: number, options?: AccessOptions): Promise<Walked>;
+export declare function refused(path: string, errno?: string): Error & {
+    code: string;
+};