@ai-ecoverse/slicc-kernel 1.102.5 → 1.103.0

package/dist/types/process/js/js-sync.d.ts

@@ -0,0 +1,86 @@
+import type { JsLane } from '../../kernel/protocol.js';
+import { type SyncFsBridgeStat, type SyncFsResult } from '../../realm/sync-fs-wire.js';
+import type { SyncSabRequestBody } from '../../realm/sync-sab-wire.js';
+import type { JsChild, JsSpawnOptions } from './js-children.js';
+import { type FdInfo, type JsOpenOptions, type JsStatFs } from './js-io.js';
+import { type JsKernel } from './js-kernel.js';
+import type { JsRunOptions, JsRunResult } from './js-run.js';
+export type SyncCall = (req: SyncSabRequestBody) => SyncFsResult;
+export interface JsSyncFile {
+    readonly fd: number;
+    readonly path: string;
+    size(): number;
+    read(position: number, length: number): Uint8Array;
+    write(position: number, data: Uint8Array): number;
+    truncate(size: number): void;
+    sync(): void;
+    close(): void;
+}
+export interface JsCred {
+    ruid: number;
+    euid: number;
+    suid: number;
+    rgid: number;
+    egid: number;
+    sgid: number;
+    groups: number[];
+}
+export interface JsSyncContext {
+    readonly kernel: {
+        readonly version: string;
+    };
+    run(options: JsRunOptions): JsRunResult;
+    spawn(options: JsSpawnOptions): JsChild;
+    exit(status?: number): never;
+    kill(pid: number, signal?: number | `SIG${string}`): void;
+    cred(): JsCred;
+    umask(mask?: number): number;
+    setcred(change: Partial<JsCred>): JsCred;
+    read(fd: number, max?: number): Uint8Array;
+    write(fd: number, data: Uint8Array | string): void;
+    close(fd: number): void;
+    open(path: string, options?: JsOpenOptions): JsSyncFile;
+    fs: {
+        stat(path: string): SyncFsBridgeStat;
+        lstat(path: string): SyncFsBridgeStat;
+        exists(path: string): boolean;
+        readdir(path: string): string[];
+        mkdir(path: string, options?: {
+            recursive?: boolean;
+            mode?: number;
+        }): void;
+        rm(path: string): void;
+        unlink(path: string): void;
+        rename(from: string, to: string): void;
+        chmod(path: string, mode: number): void;
+        link(from: string, to: string): void;
+        symlink(target: string, path: string): void;
+        readlink(path: string): string;
+        statfs(path: string): JsStatFs;
+        readFile(path: string): Uint8Array;
+        writeFile(path: string, data: Uint8Array | string, options?: {
+            mode?: number;
+        }): void;
+    };
+}
+export interface SyncShared {
+    pid: number;
+    resolve(path: string): string;
+    random(bytes: Uint8Array): void;
+    infos: Map<number, FdInfo>;
+    handles: Map<number, () => void>;
+}
+export declare const noLane: SyncCall;
+export declare function laneOf(lane: JsLane | undefined): SyncCall;
+export declare class JsSyncKernel {
+    private readonly lane;
+    private readonly kernel;
+    private readonly unwind;
+    constructor(lane: SyncCall, kernel: Pick<JsKernel, 'deliver'>, unwind?: () => void);
+    raw(req: SyncSabRequestBody): SyncFsResult;
+    call(req: SyncSabRequestBody): SyncFsResult;
+    json(req: SyncSabRequestBody): unknown;
+    bytes(req: SyncSabRequestBody): Uint8Array;
+    blocking(req: SyncSabRequestBody): SyncFsResult;
+}
+export declare function syncOps(kernel: JsSyncKernel, shared: SyncShared): Omit<JsSyncContext, 'run' | 'spawn' | 'exit' | 'kill' | 'cred' | 'setcred' | 'kernel' | 'umask'>;

package/dist/types/process/js/js-tty.d.ts

@@ -0,0 +1,30 @@
+import type { JsKernel } from './js-kernel.js';
+export interface JsTermios {
+    c_iflag: number;
+    c_oflag: number;
+    c_cflag: number;
+    c_lflag: number;
+    c_cc: number[];
+}
+export interface JsTtySize {
+    columns: number;
+    rows: number;
+}
+export interface JsTty {
+    getAttr(fd: number): Promise<JsTermios>;
+    setAttr(fd: number, termios: JsTermios): Promise<void>;
+    setRaw(fd: number, raw: boolean): Promise<void>;
+    size(fd: number): Promise<JsTtySize>;
+    foreground(fd: number): Promise<number>;
+    setForeground(fd: number, pgrp: number): Promise<void>;
+}
+export declare function rawOf(termios: JsTermios): JsTermios;
+export declare function ttyOps(kernel: JsKernel): {
+    tty: JsTty;
+    restore(): Promise<void>;
+    modes(): Array<{
+        terminal: string;
+        fd: number;
+        termios: JsTermios;
+    }>;
+};

package/dist/types/process/js/js-websocket.d.ts

@@ -0,0 +1,21 @@
+import { type JsKernel } from './js-kernel.js';
+export type JsWebSocketMessage = string | Uint8Array;
+export interface JsWebSocketClose {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+}
+export interface JsWebSocketOptions {
+    protocols?: string | string[];
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+}
+export interface JsWebSocket {
+    readonly url: string;
+    readonly protocol: string;
+    readonly readable: ReadableStream<JsWebSocketMessage>;
+    readonly writable: WritableStream<JsWebSocketMessage>;
+    readonly closed: Promise<JsWebSocketClose>;
+    close(close?: Partial<JsWebSocketClose>): void;
+}
+export declare function websocketOp(kernel: JsKernel): (input: string | URL, options?: JsWebSocketOptions) => Promise<JsWebSocket>;

package/dist/types/process/kernel-streams.d.ts

@@ -0,0 +1,196 @@
+import type { HeldMeta, PollState } from '../kernel/fd-table.js';
+import type { MountLine, ProcessListing } from '../kernel/proc-info.js';
+import type { Termios } from '../kernel/tty.js';
+import type { EmscriptenFsForHook } from '../realm/emscripten-vfs-hook.js';
+export declare const O_NONBLOCK = 2048;
+export declare class ProcessExit extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+export declare class SyscallError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export interface ReadOptions {
+    nonblock?: boolean;
+    peek?: boolean;
+}
+export interface ProcessSys {
+    read(fd: number, max: number, opts?: ReadOptions): Uint8Array;
+    write(fd: number, bytes: Uint8Array, opts?: {
+        nonblock?: boolean;
+    }): number;
+    close(fd: number): void;
+    pipe(): [number, number];
+    poll(fd: number): PollState;
+    openVfs(path: string, flags: number, position: number, opts?: {
+        contents?: Uint8Array;
+        orphan?: boolean;
+        truncate?: boolean;
+        create?: boolean;
+        created?: boolean;
+        pin?: {
+            version: string;
+            size: number;
+        };
+        handle?: number;
+    }): number;
+    seek(fd: number, offset: number, whence: number): number;
+    flush(fd: number): void;
+    pread?(fd: number, max: number, at: number): Uint8Array;
+    pwrite?(fd: number, bytes: Uint8Array, at: number): number;
+    isatty?(fd: number): boolean;
+    ttyName?(fd: number): string | undefined;
+    kind?(fd: number): string | undefined;
+    heldMeta?(fd: number): HeldMeta | undefined;
+    access?(fd: number): 'read' | 'write' | undefined;
+    size?(fd: number): number;
+    fdStat?(fd: number): object | undefined;
+    fdChmod?(fd: number, mode: number): void;
+    fdChown?(fd: number, uid: number | undefined, gid: number | undefined): void;
+    fdUtimes?(fd: number, atimeMs: number | null, mtimeMs: number | null, now: boolean): void;
+    openTty?(name?: string): number;
+    ttyNames?(): string[];
+    ttyOwner?(name: string): TtyOwner | null;
+    tcgets?(fd: number): Termios;
+    tcsets?(fd: number, termios: Termios, flush?: boolean): void;
+    winsize?(fd: number): [number, number];
+    openPty?(): number;
+    openPts?(n: number, noctty: boolean): number;
+    ptyNumbers?(): number[];
+    openSealed?(flags: number): number;
+    openClipboard?(flags: number): number;
+    clipboardAbort?(fd: number): void;
+    procList?(): ProcessListing;
+    mountList?(): MountLine[];
+}
+export interface StreamOps {
+    getattr?: (stream: ProcessStream) => object;
+    llseek?: (stream: ProcessStream, offset: number, whence: number) => number;
+    read?: (stream: ProcessStream, buffer: Uint8Array, offset: number, length: number) => number;
+    write?: (stream: ProcessStream, buffer: Uint8Array, offset: number, length: number) => number;
+    close?: (stream: ProcessStream) => void;
+    dup?: (stream: ProcessStream) => void;
+    poll?: (stream: ProcessStream) => number;
+    fsync?: (stream: ProcessStream) => unknown;
+    mmap?: unknown;
+}
+export interface ProcessStream {
+    fd: number;
+    stream_ops: StreamOps;
+    sliccKernelFd?: number;
+    sliccKernelFile?: boolean;
+    sliccCloexec?: boolean;
+    sliccKernelSocket?: boolean;
+    path?: string;
+    flags: number;
+    position: number;
+    tty?: unknown;
+    node: {
+        mode: number;
+        mount?: {
+            type?: unknown;
+        };
+        node_ops?: {
+            getattr?: (node: ProcessStream['node']) => object;
+        };
+    };
+    shared: object;
+}
+export interface ProcessFs extends EmscriptenFsForHook {
+    streams: (ProcessStream | null | undefined)[];
+    getStream(fd: number): ProcessStream | null;
+    open(path: string, flags: number, mode?: number): ProcessStream;
+    dupStream(stream: ProcessStream, fd: number): ProcessStream;
+    closeStream(fd: number): void;
+    close?(stream: ProcessStream): void;
+    isFile(mode: number): boolean;
+    mkdirTree(path: string): void;
+    cwd(): string;
+    read(stream: ProcessStream, buffer: Uint8Array, offset: number, length: number, position?: number): number;
+    write(stream: ProcessStream, buffer: Uint8Array, offset: number, length: number): number;
+    stat?(path: string, dontFollow?: boolean): object;
+    writeFile?(path: string, data: string | Uint8Array): void;
+    fstat?(fd: number): object;
+    symlink?(target: string, path: string): void;
+    lookupPath?(path: string, opts?: {
+        follow?: boolean;
+    }): {
+        node: object;
+    };
+}
+export interface ProcessPipeFs {
+    createPipe(): {
+        readable_fd: number;
+        writable_fd: number;
+    };
+}
+export interface KernelStreamOptions {
+    sigpipe?: () => boolean;
+    restartable?: () => boolean;
+    owners?: boolean;
+    program?: string;
+}
+export interface TtyOwner {
+    uid: number;
+    gid: number;
+    mode?: number;
+}
+export declare class KernelStreams {
+    private readonly refs;
+    private socketRoot;
+    private sockets;
+    private readonly descriptions;
+    private described;
+    private readonly Fs;
+    private readonly sys;
+    private readonly options;
+    constructor(Fs: ProcessFs, sys: ProcessSys, options?: KernelStreamOptions);
+    attach(stream: ProcessStream, kfd: number, terminal?: boolean): void;
+    attachSocket(stream: ProcessStream, kfd: number): void;
+    socketStream(flags: number): ProcessStream;
+    nameTerminal(stream: ProcessStream): void;
+    private nameStream;
+    nameDevice(stream: ProcessStream, kind: 'sealed' | 'clipboard'): void;
+    private listSealed;
+    private openNode;
+    private readonly reporting;
+    reportClose(kfd: number): void;
+    quitting: boolean;
+    private atExit;
+    private failedAtExit;
+    private readonly committed;
+    exiting(): () => void;
+    private commitStdout;
+    exitStatus(status: number): number;
+    private reportedClose;
+    private stdoutFailed;
+    private creatingTerminal;
+    private useTerminalNodes;
+    private ttyNode;
+    private ttyOps;
+    attachFile(stream: ProcessStream, kfd: number): void;
+    sizeFromKernel(stream: ProcessStream, kfd: number): void;
+    describe(stream: ProcessStream, name: string, getattr: () => object): void;
+    private useDescriptions;
+    useKernelFdMetadata(): void;
+    useControllingTerminal(): void;
+    private openRacing;
+    private refuseExclusiveLink;
+    private openPty;
+    private openSealed;
+    private openClipboard;
+    private vessel;
+    private usePtyPaths;
+    private ownedTty;
+    private owned;
+    private existingPty;
+    private devicePath;
+    private terminalExists;
+    private openNamedTerminal;
+    private stdioTerminal;
+    usePipes(pipefs: ProcessPipeFs): void;
+    private restarting;
+    private call;
+    private ops;
+}

package/dist/types/process/process-fds.d.ts

@@ -0,0 +1,95 @@
+import type { MountLine } from '../kernel/proc-info.js';
+import type { ProcessFs, ProcessStream, ProcessSys } from './kernel-streams.js';
+import { type LockDeps } from './process-locks.js';
+import { type PtyKernel } from './process-pty.js';
+export declare const O_CLOEXEC = 524288;
+type CloexecStream = Pick<ProcessStream, 'sliccCloexec'>;
+export declare function closesOnExec(stream: CloexecStream): boolean;
+export declare function setCloseOnExec(stream: CloexecStream, on: boolean): void;
+export declare function trackCloseOnExec(Fs: ProcessFs): void;
+export type GlueSyscall = (...args: number[]) => number;
+export interface GlueSyscalls {
+    fcntl?: GlueSyscall;
+    pipe2?: GlueSyscall;
+    dup3?: GlueSyscall;
+    socket?: GlueSyscall;
+    accept4?: GlueSyscall;
+    ioctl?: GlueSyscall;
+    setitimer?: GlueSyscall;
+}
+export interface CloexecDeps {
+    fs(): ProcessFs | undefined;
+    heap(): Int32Array | undefined;
+    pty?: PtyKernel;
+    timer?: {
+        arm(ms: number): void;
+    };
+    locks?: Omit<LockDeps, 'fs'>;
+}
+export declare function wrapCloexecSyscalls(imports: WebAssembly.Imports, glue: GlueSyscalls | undefined, deps: CloexecDeps): void;
+export declare function pathOpensLinks(Fs: ProcessFs): void;
+type Syscall = (...args: number[]) => number;
+export interface KernelImports {
+    openat?: unknown;
+    mkdirat?: unknown;
+    mknodat?: unknown;
+    umask?: unknown;
+    faccessat?: unknown;
+    linkat?: unknown;
+    symlinkat?: unknown;
+    uname?: unknown;
+    utimensat?: unknown;
+    getppid?: unknown;
+    resizeHeap?: unknown;
+    fdWrite?: unknown;
+    fdRead?: unknown;
+    sleepMs?: unknown;
+}
+export declare function importKey(namespace: WebAssembly.ModuleImports, name: keyof KernelImports, glue: KernelImports | undefined): string | undefined;
+export declare function wrapImport(imports: WebAssembly.Imports, name: keyof KernelImports, glue: KernelImports | undefined, wrap: (original: Syscall) => Syscall, optional?: boolean): void;
+export interface UmaskDeps {
+    initial: number;
+    memory(): WebAssembly.Memory | undefined;
+    set(mask: number): void;
+    glue?: KernelImports | undefined;
+}
+export declare function kernelUmask(imports: WebAssembly.Imports, deps: UmaskDeps): void;
+export declare function noFollowUtimes(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, glue?: unknown, memory?: () => WebAssembly.Memory | undefined): void;
+export interface FdImports {
+    fd_sync?: unknown;
+    fd_pread?: unknown;
+    fd_pwrite?: unknown;
+}
+export declare function syncFsync(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, glue?: FdImports): void;
+interface PositionalDeps {
+    glue?: FdImports | undefined;
+    fs: () => ProcessFs | undefined;
+    sys: Pick<ProcessSys, 'pread' | 'pwrite'>;
+    memory: () => WebAssembly.Memory | undefined;
+}
+export declare function positionalIo(imports: WebAssembly.Imports, deps: PositionalDeps): void;
+export type Memalign = (alignment: number, size: number) => number;
+export interface MmapDeps {
+    sys: Pick<ProcessSys, 'pread'>;
+    memory: () => WebAssembly.Memory | undefined;
+    memalign: () => Memalign | undefined;
+}
+export declare function useFileMmap(Fs: ProcessFs, deps: MmapDeps): void;
+export declare function wasmMemory(instance: WebAssembly.Instance, imports: WebAssembly.Imports): WebAssembly.Memory | undefined;
+export declare function fdOfPath(path: string, cwd: string): number | undefined;
+export declare function useZeroDevices(Fs: ProcessFs): void;
+export declare function useDevRemoval(Fs: ProcessFs): void;
+export declare function useDevFd(Fs: ProcessFs): void;
+export declare function pinRootKind(): void;
+export declare function mountTable(mounts?: MountLine[]): string;
+export declare function accounts(env?: Record<string, string>): {
+    passwd: string;
+    group: string;
+};
+export declare function useMounts(Fs: ProcessFs, env?: Record<string, string>, live?: boolean): void;
+export declare function kernelAccess(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, memory: () => WebAssembly.Memory | undefined, glue?: KernelImports): void;
+export declare function kernelLink(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, memory: () => WebAssembly.Memory | undefined, glue?: KernelImports): void;
+export declare function devCreations(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, memory: () => WebAssembly.Memory | undefined, glue?: KernelImports): void;
+export declare function kernelUname(imports: WebAssembly.Imports, hostname: string, memory: () => WebAssembly.Memory | undefined, glue?: KernelImports): void;
+export declare function linuxDevices(Fs: ProcessFs): void;
+export {};

package/dist/types/process/process-locks.d.ts

@@ -0,0 +1,29 @@
+import type { ProcessFs, ProcessStream } from './kernel-streams.js';
+export declare const F_GETLK = 12;
+export declare const F_SETLK = 13;
+export declare const F_SETLKW = 14;
+export type LockKind = 'read' | 'write';
+export interface LockTarget {
+    path?: string;
+    fd?: number;
+}
+export interface LockHeld {
+    kind: LockKind;
+    pid: number;
+    start: number;
+    len: number;
+}
+export interface LockKernel {
+    setLock(target: LockTarget, kind: LockKind | 'unlock', start: number, len: number, wait: boolean): void;
+    getLock(target: LockTarget, kind: LockKind, start: number, len: number): LockHeld | null;
+    closeLocks(target: LockTarget): void;
+}
+export interface LockDeps {
+    fs(): ProcessFs | undefined;
+    memory(): ArrayBufferLike | undefined;
+    kernel: LockKernel;
+    flush(): void;
+}
+export declare function lockTarget(stream: ProcessStream): LockTarget | undefined;
+export declare function recordLock(fcntl: (fd: number, cmd: number, varargs: number) => number, deps: LockDeps): (fd: number, cmd: number, varargs: number) => number;
+export declare function closeDropsLocks(Fs: ProcessFs, kernel: LockKernel): void;

package/dist/types/process/process-pty.d.ts

@@ -0,0 +1,20 @@
+import type { ProcessFs } from './kernel-streams.js';
+import type { GlueSyscall } from './process-fds.js';
+export declare const TIOCGPTN = 2147767344;
+export declare const TIOCSPTLCK = 1074025521;
+export declare const TIOCSCTTY = 21518;
+export declare const TIOCSWINSZ = 21524;
+export declare const TIOCPKT = 21536;
+export interface PtyKernel {
+    ptyNumber(kfd: number): number;
+    ptyLock(kfd: number, lock: boolean): void;
+    setControllingTerminal(kfd: number): void;
+    setPacketMode(kfd: number, on: boolean): void;
+    setWinsize(kfd: number, rows: number, cols: number): void;
+}
+export interface PtyIoctlDeps {
+    fs(): ProcessFs | undefined;
+    heap(): Int32Array | undefined;
+    kernel: PtyKernel;
+}
+export declare function ptyIoctl(ioctl: GlueSyscall, deps: PtyIoctlDeps): GlueSyscall;

package/dist/types/process/process-signals.d.ts

@@ -0,0 +1,33 @@
+import type { SyncSabTransport } from '../realm/sync-sab-bridge.js';
+export interface SignalHooks {
+    masks(): {
+        caught: number;
+        ignored: number;
+        restart: number;
+        defaults?: number;
+    } | null;
+    raise(sig: number): void;
+    timer?(which: number): void;
+    killed?(code: number): void;
+}
+export declare class SignalGate {
+    private reported;
+    private restart;
+    private lastDelivered;
+    private depth;
+    private reporting;
+    private unwinding;
+    private quieted;
+    private delivered;
+    private readonly raw;
+    private readonly header;
+    private readonly hooks;
+    constructor(raw: SyncSabTransport, header: Int32Array, hooks: SignalHooks);
+    transport(): SyncSabTransport;
+    deliveries(): number;
+    restartable(): boolean;
+    private report;
+    quiet<T>(fn: () => T): T;
+    interrupt(): boolean;
+    deliver(): void;
+}

package/dist/types/process/procfs.d.ts

@@ -0,0 +1,41 @@
+import type { MountLine, ProcessInfo, ProcessListing } from '../kernel/proc-info.js';
+export declare const PID_FILES: readonly ['cmdline', 'comm', 'stat', 'statm', 'status'];
+export declare const SYSTEM_FILES: readonly ['loadavg', 'meminfo', 'stat', 'uptime', 'version'];
+export interface ProcSysTree {
+    readonly [name: string]: string | ProcSysTree;
+}
+export declare const SYS_TREE: ProcSysTree;
+export declare function sysEntry(parts: readonly string[]): string | ProcSysTree | undefined;
+type PidFile = (typeof PID_FILES)[number];
+type SystemFile = (typeof SYSTEM_FILES)[number];
+export interface ProcSys {
+    procList?(): ProcessListing;
+    mountList?(): MountLine[];
+}
+export interface MemorySource {
+    deviceMemory?: number;
+    usedHeap?: number;
+}
+export declare function commOf(info: ProcessInfo): string;
+export declare function ttyNumber(tty: string | null): number;
+export declare function pidStat(info: ProcessInfo, boot: number, state?: string): string;
+export declare function taskStat(info: ProcessInfo, tid: number, boot: number): string | undefined;
+export declare function taskIds(info: ProcessInfo): number[];
+export declare function pidStatus(info: ProcessInfo): string;
+export declare function pidFile(name: PidFile, info: ProcessInfo, boot: number): string;
+export declare function memoryInfo(source: MemorySource, used?: number): string;
+export declare function systemFile(name: SystemFile, listing: ProcessListing, now: number, memory: MemorySource): string;
+export declare function memorySource(scope?: object): MemorySource;
+export interface ProcFs {
+    lookupPath?(path: string, opts?: {
+        follow?: boolean;
+    }): {
+        node: object;
+    };
+    createNode?(parent: object, name: string, mode: number, rdev: number): object;
+    hashRemoveNode?(node: object): void;
+    streams?: unknown[];
+    ErrnoError: new (errno: number) => Error;
+}
+export declare function useProcfs(Fs: ProcFs, sys: ProcSys, pid: number, memory?: MemorySource): void;
+export {};

package/dist/types/process/wasi/dylink.d.ts

@@ -0,0 +1,9 @@
+export interface DylinkInfo {
+    memorySize: number;
+    memoryAlign: number;
+    tableSize: number;
+    tableAlign: number;
+    needed: string[];
+    runtimePath: string[];
+}
+export declare function dylinkInfo(module: WebAssembly.Module): DylinkInfo | undefined;

package/dist/types/process/wasi/slicc-lock.d.ts

@@ -0,0 +1,26 @@
+import type { LockHeld, LockKind, LockTarget } from '../process-locks.js';
+import type { WasiFunction } from './wasi-host.js';
+import type { WasiMemory } from './wasi-memory.js';
+export declare const F_GETLK = 12;
+export declare const F_SETLK = 13;
+export declare const F_SETLKW = 14;
+export interface LockedFile {
+    target: LockTarget;
+    path?: string;
+    readable?: boolean;
+    writable?: boolean;
+    offset(): number;
+    size(): number;
+}
+export interface LockCalls {
+    set(target: LockTarget, kind: LockKind | 'unlock', start: number, len: number, wait: boolean): void;
+    get(target: LockTarget, kind: LockKind, start: number, len: number): LockHeld | null;
+}
+export interface LockHost {
+    mem: WasiMemory;
+    file(fd: number): LockedFile;
+    flush(file: LockedFile): void;
+    locked(): void;
+    calls: LockCalls;
+}
+export declare function lockImports(host: LockHost): Record<string, WasiFunction>;

package/dist/types/process/wasi/slicc-sem.d.ts

@@ -0,0 +1,3 @@
+import type { WasiFunction, WasiHost } from './wasi-host.js';
+export declare function remainingMs(deadline: bigint, now: bigint): number;
+export declare function semImports(host: WasiHost): Record<string, WasiFunction>;