@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

package/dist/types/mount/fstab.d.ts

@@ -0,0 +1,17 @@
+import type { MountEntry, MountSpec } from './mount-fs.js';
+export declare const FSTAB_PATH = "/etc/fstab";
+export declare const FSTAB_RETRIES: number[];
+export interface FstabLine {
+    line: number;
+    spec: MountSpec;
+    invalid?: Error;
+}
+export interface FstabResult {
+    line: number;
+    target: string;
+    entry?: MountEntry;
+    code?: string;
+    error?: string;
+}
+export declare function parseFstab(text: string): FstabLine[];
+export declare function mountFstab(lines: readonly FstabLine[], mount: (spec: MountSpec) => Promise<MountEntry>, signal: AbortSignal, retries?: readonly number[], discard?: (entry: MountEntry) => void, settled?: (line: FstabLine, result: FstabResult) => void): Promise<FstabResult[]>;

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

@@ -0,0 +1,24 @@
+import type { MessagePortLike } from '../client/protocol.js';
+import type { RealmTransportRequest, RealmTransportResponse } from '../kernel/net/transport.js';
+import { type FilesystemHandlers } from './driver.js';
+import { type DriverCapabilities } from './protocol.js';
+export interface DriverStart {
+    code: string;
+    driver: MessagePortLike;
+    client: MessagePortLike;
+}
+export interface DriverEnv {
+    fetch(request: Omit<RealmTransportRequest, 'signal'> & {
+        signal?: AbortSignal;
+    }): Promise<RealmTransportResponse>;
+}
+export type DriverFactory = (env: DriverEnv) => Promise<{
+    handlers: FilesystemHandlers;
+    capabilities?: DriverCapabilities;
+}> | {
+    handlers: FilesystemHandlers;
+    capabilities?: DriverCapabilities;
+};
+export declare function hostDriver(start: DriverStart, load: (code: string) => Promise<{
+    default?: unknown;
+}>): Promise<void>;

package/dist/types/mount/hostfs.d.ts

@@ -0,0 +1,129 @@
+import { type MediumHandlers } from './medium.js';
+import type { MountSpec, OpenedDriver } from './mount-fs.js';
+import type { DriverCapabilities } from './protocol.js';
+export interface HostfsGrant {
+    url: string;
+    token: string;
+    readonly?: boolean;
+    capabilities?: DriverCapabilities;
+}
+export interface HostfsPortGrant {
+    port: MessagePort;
+    token?: string;
+    capabilities?: DriverCapabilities;
+}
+export type HostfsGrantHook = (source: string, options: {
+    readonly: boolean;
+}) => Promise<HostfsGrant | HostfsPortGrant>;
+export type FetchLike = (url: string, init: RequestInit) => Promise<Response>;
+export interface HostfsEvent {
+    paths?: string[];
+    all?: boolean;
+    ping?: number;
+}
+export interface HostfsTransport {
+    readonly capabilities: DriverCapabilities;
+    readonly token: string;
+    readonly maxIo: number;
+    readonly gone?: boolean;
+    retire?(why: string): void;
+    cleanup?(op: string, body: Record<string, unknown>): Promise<unknown>;
+    call<T>(op: string, body?: Record<string, unknown>, handle?: boolean): Promise<T>;
+    read(fh: number, offset: number, size: number, ifMatch?: string): Promise<Uint8Array>;
+    write(fh: number, offset: number, bytes: Uint8Array): Promise<void>;
+    watch(signal: AbortSignal, onEvent: (event: HostfsEvent) => void, onOpen?: () => void): Promise<void>;
+}
+export type HostfsConnect = (source: string, options: {
+    readonly: boolean;
+}) => Promise<HostfsTransport>;
+export declare const HOSTFS_IO: number;
+export declare const unreachable: (err: unknown) => boolean;
+export declare class HostfsClient implements HostfsTransport {
+    private grant;
+    private readonly regrant;
+    private readonly fetch;
+    constructor(grant: HostfsGrant, regrant: () => Promise<HostfsGrant>, fetch: FetchLike);
+    get capabilities(): DriverCapabilities;
+    get token(): string;
+    get maxIo(): number;
+    private retired;
+    private readonly stop;
+    get gone(): boolean;
+    retire(why: string): void;
+    private send;
+    call<T>(op: string, body?: Record<string, unknown>, handle?: boolean): Promise<T>;
+    cleanup(op: string, body: Record<string, unknown>): Promise<unknown>;
+    read(fh: number, offset: number, size: number, ifMatch?: string): Promise<Uint8Array>;
+    write(fh: number, offset: number, bytes: Uint8Array): Promise<void>;
+    watch(signal: AbortSignal, onEvent: (event: HostfsEvent) => void, onOpen?: () => void): Promise<void>;
+}
+export declare const RESTORE_AGAIN_MS = 30000;
+export declare function hostfsHandlers(current: () => HostfsTransport, againMs?: number): MediumHandlers;
+export interface WatchLoop {
+    connect(): Promise<HostfsTransport>;
+    up(client: HostfsTransport): void;
+    event(event: HostfsEvent): void;
+    down(): void;
+    silenceMs?: number;
+    backoffMs?: [number, number];
+    connectMs?: number;
+}
+export interface Watching {
+    ready: Promise<void>;
+    kick(): void;
+}
+export declare function keepWatching(loop: WatchLoop, signal: AbortSignal): Watching;
+export declare function invalidation(event: HostfsEvent): string[] | true;
+export interface HostfsTiming {
+    silenceMs?: number;
+    backoffMs?: [number, number];
+    connectMs?: number;
+    requestMs?: number;
+    callMs?: number;
+    beatMs?: number;
+    deadMs?: number;
+}
+export declare const PORT_REQUEST_MS = 60000;
+export declare const HOSTFS_CALL_MS = 20000;
+export declare const PORT_BEAT_MS = 1000;
+export declare const PORT_DEAD_MS = 10000;
+export declare const PORT_LINGER_MS = 1000;
+export interface PortLiveness {
+    requestMs?: number;
+    beatMs?: number;
+    deadMs?: number;
+    lingerMs?: number;
+}
+export declare function timed(transport: HostfsTransport, ms: number): HostfsTransport;
+export declare class PortTransport implements HostfsTransport {
+    readonly capabilities: DriverCapabilities;
+    readonly token: string;
+    private readonly port;
+    private readonly requestMs;
+    private readonly waiting;
+    private next;
+    private dead;
+    private readonly beatMs;
+    private readonly deadMs;
+    private readonly lingerMs;
+    private beat;
+    private answers;
+    private pinged;
+    constructor(grant: HostfsPortGrant, liveness?: PortLiveness);
+    get maxIo(): number;
+    get gone(): boolean;
+    retire(why: string): void;
+    private ping;
+    private watchBeat;
+    cleanup(op: string, body: Record<string, unknown>): Promise<void>;
+    private closed;
+    fail(why: string): void;
+    private ask;
+    call<T>(op: string, body?: Record<string, unknown>): Promise<T>;
+    read(fh: number, offset: number, size: number, ifMatch?: string): Promise<Uint8Array>;
+    write(fh: number, offset: number, bytes: Uint8Array): Promise<void>;
+    watch(signal: AbortSignal, onEvent: (event: HostfsEvent) => void, onOpen?: () => void): Promise<void>;
+}
+export declare function serveHostfsPort(port: MessagePort, transport: HostfsTransport): () => void;
+export declare function grantConnect(hook: HostfsGrantHook, fetch: FetchLike, liveness?: PortLiveness): HostfsConnect;
+export declare function openHostfs(spec: MountSpec, connect: HostfsConnect, timing?: HostfsTiming): Promise<OpenedDriver>;

package/dist/types/mount/media.d.ts

@@ -0,0 +1,8 @@
+import type { MediumHandle } from './fsa.js';
+export interface MediaStore {
+    get(id: string): Promise<MediumHandle | undefined>;
+    put(id: string, handle: MediumHandle): Promise<void>;
+}
+export declare const MEDIA_STORE = "handles";
+export declare function memoryMedia(): MediaStore;
+export declare function openMedia(name: string, factory: IDBFactory): Promise<MediaStore>;

package/dist/types/mount/medium.d.ts

@@ -0,0 +1,12 @@
+import { type FilesystemHandlers } from './driver.js';
+export type MediumHandlers = Required<Omit<FilesystemHandlers, 'mount' | 'statfs' | 'link'>> & Pick<FilesystemHandlers, 'statfs'>;
+export interface MediumSlot<K> {
+    readonly handlers: FilesystemHandlers;
+    present(): boolean;
+    insert(key: K, handlers: MediumHandlers): void;
+    eject(): void;
+}
+export declare const absent: () => Error & {
+    code: string;
+};
+export declare function mediumSlot<K>(lost: (err: unknown, key: K) => Promise<boolean>, onLost: (key: K) => void): MediumSlot<K>;

package/dist/types/mount/mount-fs.d.ts

@@ -0,0 +1,136 @@
+import { type KernelFs } from '../fs/types.js';
+import type { KeptFile, UnlinkHolder } from '../fs/unlinked.js';
+import { DriverConnection, type DriverPortLike } from './connection.js';
+import type { DriverAttr, DriverCapabilities, DriverEntry } from './protocol.js';
+export interface MountSpec {
+    type: string;
+    source: string;
+    target: string;
+    options?: Record<string, string>;
+}
+export interface MountEntry {
+    type: string;
+    source: string;
+    target: string;
+    options: Record<string, string>;
+    state: 'ok' | 'failed' | 'nomedium' | 'pending';
+    error?: string;
+}
+export interface OpenedDriver {
+    port: DriverPortLike;
+    dispose(): void;
+    onCrash?(listener: (error: Error) => void): void;
+    present?(): boolean;
+    idle?: true;
+}
+export interface MountDeps {
+    open(type: string, spec: MountSpec): Promise<OpenedDriver>;
+    busy(target: string): boolean;
+    changed?(...paths: string[]): void;
+    reshaped?(): void;
+    timeoutMs?: number;
+    owners?: boolean;
+}
+interface Cached<T> {
+    value: T;
+    expires: number;
+}
+interface Mount extends MountEntry {
+    dev: number;
+    conn: DriverConnection;
+    caps: DriverCapabilities;
+    maxFile: number;
+    attrs: Map<string, Cached<DriverAttr>>;
+    lists: Map<string, Cached<DriverEntry[]>>;
+    epoch: number;
+    owners: boolean;
+    dispose(): void;
+    present?(): boolean;
+}
+export declare function parseSize(text: string): number;
+export declare class HeldSet extends Set<HeldPaths> {
+    private readonly idle;
+    constructor(idle: (path: string) => void);
+    add(holds: HeldPaths): this;
+    delete(holds: HeldPaths): boolean;
+}
+export declare function heldUnder(held: Iterable<Map<string, number>>, target: string): boolean;
+export declare class HeldPaths extends Map<string, number> implements UnlinkHolder {
+    private readonly revoked;
+    readonly opens: Map<string, number>;
+    readonly unlinked: Map<string, KeptFile>;
+    private readonly aliases;
+    private readonly handles;
+    private readonly keptHandles;
+    private readonly uses;
+    private lastHandle;
+    private owning;
+    onIdle?: (path: string) => void;
+    keyOf(path: string): string;
+    keptAt(path: string): KeptFile | undefined;
+    holding(path: string): boolean;
+    held(): Iterable<string>;
+    isKept(path: string): boolean;
+    private handlesAt;
+    keptFor(handle: number): KeptFile | undefined;
+    keeps(hidden: string): boolean;
+    keep(path: string, file: KeptFile): void;
+    unkeep(path: string, file: KeptFile): void;
+    private letGo;
+    releaseAll(): void;
+    hold(path: string, on: boolean, open?: boolean, real?: string, handle?: number): number | undefined;
+    private holdOpen;
+    private holdWrite;
+    own<T>(path: string, op: () => Promise<T>): Promise<T>;
+    owns(path: string): boolean;
+    revoke(prefix: string): void;
+    renamed(from: string, to: string): void;
+    isRevoked(path: string): boolean;
+}
+interface WriteSession {
+    mount: Mount;
+    fh: Promise<number>;
+    extents: Array<[number, number]>;
+    truncated: boolean;
+}
+export declare class MountTable {
+    private readonly mounts;
+    private readonly sessions;
+    private readonly committing;
+    private devices;
+    private readonly pending;
+    private readonly notes;
+    private readonly system;
+    private readonly deps;
+    constructor(deps: MountDeps);
+    mounted(target: string): MountEntry | undefined;
+    list(): MountEntry[];
+    listed(): MountEntry[];
+    mountSystem(spec: MountSpec, fs: KernelFs): Promise<void>;
+    note(spec: MountSpec, state: 'pending' | 'failed', error?: string): void;
+    under(path: string): boolean;
+    locate(path: string): {
+        mount: Mount;
+        rel: string;
+    } | undefined;
+    mount(spec: MountSpec, fs: KernelFs): Promise<MountEntry>;
+    private attach;
+    unnote(target: string): void;
+    umount(target: string, detach?: boolean): void;
+    session(mount: Mount, real: string, rel: string): WriteSession;
+    writing(real: string): WriteSession | undefined;
+    commit(real: string): Promise<void>;
+    commitUnder(prefix: string): Promise<void>;
+    commitOverlapping(real: string, offset: number, length: number): Promise<void>;
+    private crashed;
+    private invalidated;
+    forget(mount: Mount, path: string): void;
+    getattr(mount: Mount, path: string, rel: string, settled?: boolean): Promise<DriverAttr>;
+    readdir(mount: Mount, path: string, rel: string): Promise<DriverEntry[]>;
+    statfs(path: string): Promise<{
+        quota: number;
+        usage: number;
+    } | undefined>;
+    wrap(base: KernelFs): KernelFs;
+}
+export {};

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

@@ -0,0 +1,140 @@
+export declare const DRIVER_PROTOCOL: readonly [number, number];
+export interface DriverCapabilities {
+    readonly?: boolean;
+    symlinks?: boolean;
+    links?: boolean;
+    chmod?: boolean;
+    owners?: boolean;
+    linkTimes?: boolean;
+    ranges?: boolean;
+    sessions?: boolean;
+    listingStats?: boolean;
+    caseInsensitive?: boolean;
+    normalization?: 'none' | 'nfc' | 'nfd-insensitive';
+    maxIo?: number;
+    maxFile?: number;
+    attrTtl?: number;
+    entryTtl?: number;
+}
+export interface DriverAttr {
+    kind: 'file' | 'directory' | 'symlink';
+    size: number;
+    mtime: number;
+    atime?: number;
+    mode?: number;
+    ino?: number;
+    nlink?: number;
+    etag?: string;
+    uid?: number;
+    gid?: number;
+}
+export interface DriverOwner {
+    uid?: number;
+    gid?: number;
+    mode?: number;
+}
+export interface DriverEntry {
+    name: string;
+    kind: DriverAttr['kind'];
+    attr?: DriverAttr;
+}
+export interface DriverStatfs {
+    bsize: number;
+    blocks: number;
+    bfree: number;
+}
+export interface MountRequestInfo {
+    source: string;
+    options: Record<string, string>;
+}
+export type DriverCall = {
+    op: 'getattr';
+    path: string;
+} | {
+    op: 'readdir';
+    path: string;
+} | ({
+    op: 'open';
+    path: string;
+    write: boolean;
+    create: boolean;
+    truncate: boolean;
+    exclusive: boolean;
+    ifMatch?: string;
+} & DriverOwner) | {
+    op: 'read';
+    fh: number;
+    offset: number;
+    size: number;
+} | {
+    op: 'write';
+    fh: number;
+    offset: number;
+    bytes: Uint8Array;
+} | {
+    op: 'release';
+    fh: number;
+} | ({
+    op: 'mkdir';
+    path: string;
+} & DriverOwner) | {
+    op: 'rmdir';
+    path: string;
+} | {
+    op: 'unlink';
+    path: string;
+} | {
+    op: 'rename';
+    from: string;
+    to: string;
+} | {
+    op: 'link';
+    from: string;
+    to: string;
+} | ({
+    op: 'symlink';
+    target: string;
+    path: string;
+} & DriverOwner) | {
+    op: 'readlink';
+    path: string;
+} | {
+    op: 'setattr';
+    path: string;
+    mode?: number;
+    mtime?: number;
+    atime?: number;
+    size?: number;
+    uid?: number;
+    gid?: number;
+} | {
+    op: 'statfs';
+};
+export type DriverRequest = DriverCall & {
+    id: number;
+};
+export interface DriverReply {
+    id: number;
+    result?: unknown;
+    errno?: string;
+    message?: string;
+}
+export interface KernelDriverHello {
+    protocol: readonly [number, number];
+    mount: MountRequestInfo;
+}
+export interface DriverHello {
+    protocol: readonly [number, number];
+    capabilities?: DriverCapabilities;
+    error?: string;
+    errno?: string;
+}
+export type KernelToDriver = {
+    hello: KernelDriverHello;
+} | DriverRequest;
+export type DriverToKernel = {
+    hello: DriverHello;
+} | DriverReply | {
+    invalidate: string[] | true;
+};
+export declare function driverVersionError(theirs: unknown): string | undefined;

package/dist/types/mount/syscall.d.ts

@@ -0,0 +1,27 @@
+import { type MountSpec } from './mount-fs.js';
+export declare const MS_RDONLY = 1;
+export declare const MNT_FORCE = 1;
+export declare const MNT_DETACH = 2;
+export interface MountCall {
+    source: string;
+    target: string;
+    type: string;
+    flags: number;
+    data: string;
+}
+export interface ProcessMountRequest {
+    op: 'mount' | 'umount';
+    pid: number;
+    target: string;
+    type?: string;
+    source?: string;
+    options?: Record<string, string>;
+}
+export type ProcessMountPolicy = boolean | ((req: ProcessMountRequest) => boolean | Promise<boolean>);
+export declare function parseMountOptions(data: string): Record<string, string>;
+export declare function refusedTarget(target: string): void;
+export declare function mountCall(call: MountCall): MountSpec;
+export declare function umountCall(target: string, flags: number): {
+    target: string;
+    detach: boolean;
+};

package/dist/types/mount/tmpfs.d.ts

@@ -0,0 +1,2 @@
+import { type FilesystemHandlers } from './driver.js';
+export declare function tmpfs(): FilesystemHandlers;

package/dist/types/node/loopback.d.ts

@@ -0,0 +1,11 @@
+import type { RealmTransport } from '../kernel/net/transport.js';
+export type HostLoopback = boolean | readonly number[];
+export declare const DEVTOOLS_PORTS: readonly number[];
+export type Resolve = (host: string) => Promise<string[]>;
+type Place = 'loopback' | 'link-local';
+export declare const resolveHost: Resolve;
+export declare function placeOf(address: string): Place | undefined;
+export declare function checkDestination(target: string, policy: HostLoopback, resolve?: Resolve): Promise<void>;
+export declare function proxiedConnections(): number;
+export declare function guardedLoopback(transport: RealmTransport, policy: HostLoopback, resolve?: Resolve): RealmTransport;
+export {};

package/dist/types/node/memory-root.d.ts

@@ -0,0 +1,2 @@
+export declare function memoryRoot(): FileSystemDirectoryHandle;
+export declare function isMemoryRoot(handle: FileSystemDirectoryHandle): boolean;

package/dist/types/node/ws-diagnose.d.ts

@@ -0,0 +1,4 @@
+import type { RealmTransport } from '../kernel/net/transport.js';
+export type Diagnose = (url: string, signal?: AbortSignal) => Promise<string | undefined>;
+export declare function diagnose(url: string, ms?: number, signal?: AbortSignal): Promise<string | undefined>;
+export declare function diagnosing(transport: RealmTransport, check?: Diagnose): RealmTransport;

package/dist/types/node.d.ts

@@ -0,0 +1,85 @@
+import { type MessagePort } from 'node:worker_threads';
+import type { CdpHook } from './cdp/types.js';
+import type { FacadeSpecs } from './facade/types.js';
+import type { DenialHook } from './fs/dac.js';
+import type { Protection } from './fs/protect.js';
+import { type UsersMode } from './fs/types.js';
+import type { ConnectOptions, KernelGroups, KernelIntegrity, KernelUsers, RunOptions, RunResult, Terminal, TerminalOptions } from './index.js';
+import type { ClipboardHook } from './kernel/clipboard.js';
+import type { RouteTable } from './kernel/net/routes.js';
+import type { NetworkUplink } from './kernel/net/uplink.js';
+import type { SealedHook } from './kernel/sealed.js';
+import type { FetchLike, HostfsGrantHook } from './mount/hostfs.js';
+import type { MountEntry, MountSpec } from './mount/mount-fs.js';
+import type { ProcessMountPolicy } from './mount/syscall.js';
+import { type HostLoopback } from './node/loopback.js';
+import { memoryRoot } from './node/memory-root.js';
+import type { ApproveHook } from './sudo.js';
+import { type NetworkTransport } from './transport.js';
+export type { CdpConnection, CdpHook, CdpRequest } from './cdp/types.js';
+export { type AttachOptions, attachKernel, type ClientEnded, type ClientFetchRequest, type ClientFs, type ClientRunOptions, type ClientRunResult, type ClientTerminal, type ClientTerminalOptions, KernelCallError, type KernelClient, KernelGoneError, type ProcessEntry, type SpawnedProcess, type SpawnOptions, type WatchChange, } from './client/attach.js';
+export type { FacadeConnection, FacadeHook, FacadeInfo, FacadeSpec, FacadeSpecs, } from './facade/types.js';
+export type { Denial, DenialHook } from './fs/dac.js';
+export type { ConnectOptions, Ended, KernelGroups, KernelIntegrity, KernelUsers, NetworkUplink, ResolveAnswer, ResolveFamily, RouteTable, RunOptions, RunResult, Terminal, TerminalOptions, TerminalSignal, } from './index.js';
+export type { ClipboardHook, ClipboardStamp } from './kernel/clipboard.js';
+export type { SealedAbortReason, SealedCaller, SealedHook, SealedRequest, } from './kernel/sealed.js';
+export type { ConnectorStamp } from './kernel/socket.js';
+export type { HostfsEvent, HostfsGrant, HostfsGrantHook, HostfsPortGrant, HostfsTransport, } from './mount/hostfs.js';
+export { serveHostfsPort } from './mount/hostfs.js';
+export type { MountEntry, MountSpec } from './mount/mount-fs.js';
+export type { ApproveHook, SudoAnswer, SudoRequest } from './sudo.js';
+export { fetchTransport, type NetworkTransport } from './transport.js';
+export { memoryRoot };
+export interface NodeKernelOptions {
+    root?: FileSystemDirectoryHandle;
+    modules?: string;
+    commands?: {
+        append?: readonly string[];
+    };
+    env?: Record<string, string>;
+    network?: {
+        transport?: NetworkTransport;
+        uplink?: NetworkUplink;
+    };
+    worker?: string | URL;
+    driverWorker?: string | URL;
+    processMounts?: ProcessMountPolicy;
+    fstabRetries?: readonly number[];
+    hostfs?: HostfsGrantHook;
+    hostfsFetch?: FetchLike;
+    hostfsOrigin?: string;
+    cdp?: CdpHook;
+    facades?: FacadeSpecs;
+    hostname?: string;
+    users?: UsersMode;
+    onDenial?: DenialHook;
+    sealed?: SealedHook;
+    clipboard?: ClipboardHook;
+    approve?: ApproveHook;
+    protect?: Protection;
+}
+export interface NodeKernel {
+    readonly root: FileSystemDirectoryHandle;
+    run(argv: string[], options?: RunOptions): Promise<RunResult>;
+    openTerminal(argv: string[], options?: TerminalOptions): Promise<Terminal>;
+    writeFile(path: string, data: string | Uint8Array, options?: {
+        mode?: number;
+    }): Promise<void>;
+    readFile(path: string): Promise<Uint8Array>;
+    chmod(path: string, mode: number): Promise<void>;
+    readonly integrity: KernelIntegrity;
+    connect(options?: ConnectOptions): Promise<MessagePort>;
+    readonly users: KernelUsers;
+    readonly groups: KernelGroups;
+    setRoutes(routes: RouteTable): Promise<void>;
+    updateTransportTraits(): Promise<boolean>;
+    mount(spec: MountSpec): Promise<MountEntry>;
+    umount(target: string): Promise<void>;
+    mounts(): Promise<MountEntry[]>;
+    terminate(): void;
+}
+export interface NodeTransportOptions {
+    hostLoopback?: HostLoopback;
+}
+export declare function nodeTransport(options?: NodeTransportOptions): NetworkTransport;
+export declare function createNodeKernel(options?: NodeKernelOptions): Promise<NodeKernel>;

package/dist/types/process/fd-metadata.d.ts

@@ -0,0 +1,4 @@
+import type { ProcessFs, ProcessSys } from './kernel-streams.js';
+type Call = <T>(syscall: () => T) => T;
+export declare function useKernelFdMetadata(Fs: ProcessFs, sys: ProcessSys, call: Call): void;
+export {};

package/dist/types/process/js/async-sab.d.ts

@@ -0,0 +1,15 @@
+import type { SyncFsResult } from '../../realm/sync-fs-wire.js';
+import type { SabPostLike } from '../../realm/sync-sab-bridge.js';
+import { type SyncSabRequestBody } from '../../realm/sync-sab-wire.js';
+export type WaitAsyncLike = (typedArray: Int32Array, index: number, value: number) => {
+    async: false;
+    value: string;
+} | {
+    async: true;
+    value: Promise<string>;
+};
+export interface AsyncSabTransport {
+    call(req: SyncSabRequestBody): Promise<SyncFsResult>;
+}
+export declare function changed(header: Int32Array, index: number, seen: number, waitAsync?: WaitAsyncLike): Promise<void>;
+export declare function createAsyncSabTransport(sab: SharedArrayBuffer, port: SabPostLike, waitAsync?: WaitAsyncLike): AsyncSabTransport;