@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

package/dist/types/process/wasi/wasix-trampoline.d.ts

@@ -0,0 +1,18 @@
+import type { FuncSig } from './wasm-functypes.js';
+export type Scalar = 'i32' | 'i64' | 'f32' | 'f64' | 'v128';
+export declare function valueTypes(codes: Uint8Array): Scalar[] | undefined;
+export declare function trampolineBytes(params: Scalar[], results: Scalar[], shared: boolean): Uint8Array<ArrayBuffer>;
+export declare class Trampolines {
+    private readonly modules;
+    get compiled(): number;
+    make(params: Scalar[], results: Scalar[], env: {
+        memory: WebAssembly.Memory;
+        table: WebAssembly.Table;
+        stackPointer: WebAssembly.Global;
+        backing: number;
+        userData: number;
+    }): {
+        fn: (...args: unknown[]) => unknown;
+        sig: FuncSig;
+    };
+}

package/dist/types/process/wasi/wasm-functypes.d.ts

@@ -0,0 +1,25 @@
+export type ValType = 'i32' | 'i64' | 'f32' | 'f64' | 'other';
+export interface FuncSig {
+    params: ValType[];
+    results: ValType[];
+}
+export interface ElemSegment {
+    offset: number;
+    tableBase: boolean;
+    funcs: number[];
+}
+export interface FuncTypeInfo {
+    sigs: FuncSig[];
+    funcs: number[];
+    exports: Record<string, number>;
+    elems: ElemSegment[];
+}
+export declare function funcTypeInfo(bytes: Uint8Array): FuncTypeInfo;
+export declare class FuncTypes {
+    private readonly known;
+    private pending;
+    register(read: () => Uint8Array | undefined, instance: WebAssembly.Instance, table: WebAssembly.Table | undefined, tableBase: number): void;
+    add(info: FuncTypeInfo, instance: WebAssembly.Instance, table: WebAssembly.Table | undefined, tableBase: number): void;
+    set(fn: object, sig: FuncSig): void;
+    of(fn: object): FuncSig | undefined;
+}

package/dist/types/process/wasi-errno.d.ts

@@ -0,0 +1 @@
+export declare function wasiErrno(code: string): number;

package/dist/types/realm/emscripten-vfs-hook.d.ts

@@ -0,0 +1,19 @@
+import { type LiveCred, type LiveMountFsApi } from './live-vfs-fs.js';
+import type { SyncFsPosixBridge } from './sync-fs-wire.js';
+export interface EmscriptenFsForHook extends LiveMountFsApi {
+    chdir(path: string): void;
+    chown?(path: string | object, uid: number, gid: number, dontFollow?: boolean): void;
+}
+export interface EmscriptenVfsHandle {
+    mounted: string[];
+    flush(): void;
+    flushDirty(): void;
+    invalidate(): void;
+}
+export interface EmscriptenVfsHookDeps {
+    bridge: SyncFsPosixBridge;
+    cwd: string;
+    warn: (message: string) => void;
+    cred?: LiveCred;
+}
+export declare function mountVfsIntoEmscripten(Fs: EmscriptenFsForHook, deps: EmscriptenVfsHookDeps): EmscriptenVfsHandle;

package/dist/types/realm/live-vfs-fs.d.ts

@@ -0,0 +1,186 @@
+import { RangedFile, type RangedWatch } from '../fs/ranged.js';
+import type { Cred } from '../kernel/cred.js';
+import { type SyncFsBridgeStat, type SyncFsPosixBridge } from './sync-fs-wire.js';
+export type LiveCred = Cred;
+interface LiveNodeState {
+    named?: number | undefined;
+    watch?: RangedWatch | undefined;
+    stat?: SyncFsBridgeStat;
+    statAt?: number;
+    data?: Uint8Array;
+    len: number;
+    loaded: boolean;
+    dirty: boolean;
+    openCount: number;
+    writers?: number;
+    orphan?: boolean;
+    kept?: boolean;
+    id?: string;
+    listed?: Map<string, SyncFsBridgeStat>;
+    maxFile?: number;
+    ranges?: boolean;
+    ranged?: RangedFile;
+    seen?: number | undefined;
+    handle?: number;
+    created?: boolean;
+}
+export interface LiveFsNode {
+    id: number;
+    name: string;
+    mode: number;
+    parent: LiveFsNode;
+    mount: LiveFsMount;
+    node_ops: LiveNodeOps;
+    stream_ops: LiveStreamOps;
+    live: LiveNodeState;
+    mounted?: unknown;
+}
+export interface LiveFsStream {
+    node: LiveFsNode;
+    position: number;
+    flags: number;
+    fd?: number;
+}
+export interface LiveFsMount {
+    opts: LiveFsMountOpts;
+    mountpoint: string;
+    root: LiveFsNode;
+}
+export interface LiveFsMountOpts {
+    root: string;
+    bridge: SyncFsPosixBridge;
+}
+interface LiveAttr {
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    blksize: number;
+    blocks: number;
+}
+interface LiveSetAttr {
+    mode?: number;
+    size?: number;
+    atime?: number | Date | null;
+    mtime?: number | Date | null;
+    timestamp?: number;
+}
+export interface LiveNodeOps {
+    getattr(node: LiveFsNode): LiveAttr;
+    setattr(node: LiveFsNode, attr: LiveSetAttr): void;
+    lookup(parent: LiveFsNode, name: string): LiveFsNode;
+    mknod(parent: LiveFsNode, name: string, mode: number, dev: number): LiveFsNode;
+    rename(oldNode: LiveFsNode, newDir: LiveFsNode, newName: string): void;
+    unlink(parent: LiveFsNode, name: string): void;
+    rmdir(parent: LiveFsNode, name: string): void;
+    readdir(node: LiveFsNode): string[];
+    symlink(parent: LiveFsNode, newName: string, target: string): LiveFsNode;
+    readlink(node: LiveFsNode): string;
+}
+export interface LiveStreamOps {
+    open(stream: LiveFsStream): void;
+    dup(stream: LiveFsStream): void;
+    close(stream: LiveFsStream): void;
+    read(stream: LiveFsStream, buffer: ArrayBufferView, offset: number, length: number, position: number): number;
+    write(stream: LiveFsStream, buffer: ArrayBufferView, offset: number, length: number, position: number): number;
+    llseek(stream: LiveFsStream, offset: number, whence: number): number;
+    fsync(stream: LiveFsStream): void;
+}
+export interface LiveFsApi {
+    createNode(parent: LiveFsNode | null, name: string, mode: number, dev?: number): LiveFsNode;
+    isDir(mode: number): boolean;
+    isFile(mode: number): boolean;
+    isLink(mode: number): boolean;
+    ErrnoError: new (errno: number) => Error & {
+        errno: number;
+    };
+    closeStream?(fd: number): void;
+    sliccTouch?: boolean;
+    sliccReading?: LiveFsNode | undefined;
+    sliccCred?: LiveCred;
+    nameTable?: (LiveFsNode | null)[] | null;
+    hashRemoveNode?(node: LiveFsNode): void;
+    lookupNode?(parent: LiveFsNode, name: string): LiveFsNode;
+    open?(...args: unknown[]): unknown;
+}
+export interface LiveVfsPlugin {
+    mount(mount: LiveFsMount): LiveFsNode;
+    node_ops: LiveNodeOps;
+    stream_ops: LiveStreamOps;
+    flushDirty(): void;
+    mounts: Set<LiveFsMount>;
+    handled?: Set<LiveFsNode>;
+}
+export declare function liveNodePath(node: LiveFsNode): string;
+export declare function createLiveVfsPlugin(Fs: LiveFsApi): LiveVfsPlugin;
+export declare function flushLiveVfs(Fs: LiveFsApi, plugin: LiveVfsPlugin): void;
+export declare function invalidateLiveVfs(Fs: LiveFsApi, plugin: LiveVfsPlugin): void;
+export interface LiveMountFsApi extends LiveFsApi {
+    root?: MemfsRoot;
+    rename?(from: string, to: string): void;
+    lookupPath?(path: string, opts?: {
+        follow?: boolean;
+        parent?: boolean;
+    }): {
+        node: object;
+    };
+    sliccRename?: true;
+    sliccKept?: true;
+    sliccStale?: true;
+    open?(path: string, flags: number, mode?: number): unknown;
+    statfsNode?(node: LiveFsNode): Record<string, number>;
+    sliccStatfs?: true;
+    filesystems: {
+        SLICC_LIVE_FS?: LiveVfsPlugin;
+    };
+    mkdirTree(path: string): void;
+    mount(type: LiveVfsPlugin, opts: LiveFsMountOpts, mountpoint: string): unknown;
+}
+export declare function mountLiveVfsDirs(Fs: LiveMountFsApi, bridge: SyncFsPosixBridge, dirs: readonly string[], warn: (message: string) => void): {
+    plugin: LiveVfsPlugin;
+    mounted: string[];
+};
+type MemfsRoot = LiveFsNode & {
+    contents?: Record<string, unknown>;
+    memfs?: LiveNodeOps;
+};
+export declare function liveRoot(Fs: LiveMountFsApi, bridge: SyncFsPosixBridge): void;
+export interface LiveChownFs extends LiveFsApi {
+    lookupPath(path: string, opts?: {
+        follow?: boolean;
+    }): {
+        node: object;
+    };
+    chown?(path: string | object, uid: number, gid: number, dontFollow?: boolean): void;
+    fchown?(fd: number, uid: number, gid: number): void;
+    getStreamChecked?(fd: number): {
+        node: object;
+        path?: string;
+    };
+}
+export declare function useLiveChown(Fs: LiveChownFs): void;
+export interface LiveLinkFs extends LiveFsApi {
+    lookupPath(path: string, opts?: {
+        follow?: boolean;
+    }): {
+        node: object;
+    };
+}
+export declare function linkLive(Fs: LiveLinkFs, from: string, to: string, follow: boolean): boolean;
+export interface LiveReadlinkFs extends LiveFsApi {
+    lookupPath(path: string, opts?: {
+        follow?: boolean;
+    }): {
+        node: object;
+    };
+    readlink?(path: string): string;
+}
+export declare function readingLinks(Fs: LiveReadlinkFs): void;
+export {};

package/dist/types/realm/sync-fs-dispatch.d.ts

@@ -0,0 +1,26 @@
+import { type Guard } from '../fs/dac.js';
+import { type SyncFsTokenEntry } from './sync-fs-token-registry.js';
+import { type SyncFsRequest, type SyncFsResult } from './sync-fs-wire.js';
+export declare function toErrno(err: unknown): SyncFsResult;
+export interface SyncFsStatJson {
+    isDirectory: boolean;
+    isFile: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+    mode: number;
+    mtimeMs: number;
+    atimeMs: number;
+    ctimeMs: number;
+    ino: number;
+    nlink?: number;
+    dev?: number;
+    readonly?: boolean;
+    maxFile?: number;
+    ranged?: boolean;
+    linkable?: boolean;
+    version?: string;
+    uid?: number;
+    gid?: number;
+}
+export declare function guardOf(entry: SyncFsTokenEntry): Guard | undefined;
+export declare function dispatchSyncFs(req: SyncFsRequest): Promise<SyncFsResult>;

package/dist/types/realm/sync-fs-token-registry.d.ts

@@ -0,0 +1,36 @@
+import type { Created, Dac } from '../fs/dac.js';
+import type { KernelFs } from '../fs/types.js';
+import type { KeptFile } from '../fs/unlinked.js';
+import type { Cred } from '../kernel/cred.js';
+export interface SyncFsTokenEntry {
+    fs: KernelFs;
+    noLinks?: KernelFs;
+    cwd: string;
+    statfs?: (path: string) => Promise<{
+        quota: number;
+        usage: number;
+    } | undefined>;
+    hold?: (path: string, held: boolean, open: boolean, real?: string, handle?: number) => number | undefined;
+    keptFor?: (handle: number) => KeptFile | undefined;
+    gate?: <T>(path: string, op: () => Promise<T>) => Promise<T>;
+    unlinked?: (path: string) => KeptFile | undefined;
+    own?: <T>(path: string, op: () => Promise<T>) => Promise<T>;
+    revoked?: (path: string) => boolean;
+    renamed?: (from: string, to: string) => void;
+    cred?: () => Readonly<Cred>;
+    umask?: () => number;
+    dac?: Dac;
+    pid?: number;
+    links?: number;
+    created?: Created;
+    holdsKept?: (path: string) => Promise<boolean>;
+    fresh?: (path: string) => void;
+    source?: SourceCheck;
+}
+export interface SourceCheck {
+    read(path: string, plain: () => Promise<Uint8Array>): Promise<Uint8Array>;
+    open(path: string, real?: string): Promise<void>;
+}
+export declare function mintSyncFsToken(entry: SyncFsTokenEntry): string;
+export declare function resolveSyncFsToken(token: string): SyncFsTokenEntry | null;
+export declare function revokeSyncFsToken(token: string): void;

package/dist/types/realm/sync-fs-wire.d.ts

@@ -0,0 +1,118 @@
+import type { ChangeView } from '../fs/changes.js';
+export declare const SYNC_FS_OPS: readonly ['read', 'write', 'exists', 'stat', 'lstat', 'readdir', 'readdir-stat', 'mkdir', 'rm', 'rename', 'link', 'unlink', 'rmdir', 'symlink', 'readlink', 'chmod', 'utimes', 'lutimes', 'statfs', 'hold', 'create', 'kept', 'pread', 'pwrite', 'append', 'truncate', 'chown', 'lchown', 'access'];
+export type AccessKind = 'open' | 'access' | 'eaccess' | 'follow';
+export declare const HOLD_READ = 4;
+export declare const HOLD_WRITE = 8;
+export declare const HOLD_CREATED = 16;
+export type SyncFsOp = (typeof SYNC_FS_OPS)[number];
+export interface SyncFsRequest {
+    token: string;
+    op: SyncFsOp;
+    path: string;
+    body?: Uint8Array;
+    arg2?: string;
+    mode?: number;
+    atimeMs?: number;
+    mtimeMs?: number;
+    offset?: number;
+    length?: number;
+    version?: string;
+    handle?: number;
+    uid?: number;
+    gid?: number;
+    exclusive?: boolean;
+    identity?: boolean;
+    now?: boolean;
+    nofollow?: boolean;
+    opening?: boolean;
+}
+export type SyncFsResult = {
+    ok: true;
+    kind: 'bytes';
+    bytes: Uint8Array;
+} | {
+    ok: true;
+    kind: 'json';
+    json: unknown;
+} | {
+    ok: true;
+    kind: 'void';
+} | {
+    ok: false;
+    errno: string;
+    message: string;
+};
+export declare const SYNC_FS_REQUEST_TIMEOUT_MS = 25000;
+export interface SyncFsBridgeStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink?: boolean;
+    size: number;
+    mode?: number;
+    mtimeMs?: number;
+    atimeMs?: number;
+    ctimeMs?: number;
+    ino?: number;
+    nlink?: number;
+    dev?: number;
+    readonly?: boolean;
+    maxFile?: number;
+    ranged?: boolean;
+    linkable?: boolean;
+    version?: string;
+    uid?: number;
+    gid?: number;
+}
+export interface SyncFsUsage {
+    quota: number;
+    usage: number;
+}
+export declare function parseSyncFsUsage(json: unknown): SyncFsUsage | null;
+export type SyncFsFileIo = Pick<SyncFsPosixBridge, 'readFile' | 'writeFile' | 'pread' | 'pwrite' | 'truncate' | 'append'>;
+export type ChownArgs = [
+    uid: number | undefined,
+    gid: number | undefined,
+    follow?: boolean,
+    handle?: number
+];
+export interface SyncFsPosixBridge {
+    changes?: ChangeView;
+    pinned?(handle: number): SyncFsFileIo;
+    kept?(handle: number): boolean;
+    keptStat?(handle: number): SyncFsBridgeStat;
+    readFile(path: string): Uint8Array;
+    writeFile(path: string, bytes: Uint8Array, open?: boolean): void;
+    stat(path: string): SyncFsBridgeStat;
+    lstat(path: string): SyncFsBridgeStat;
+    readdir(path: string): string[];
+    exists(path: string): boolean;
+    mkdir(path: string, mode?: number): void;
+    rm(path: string): void;
+    rename(from: string, to: string): void;
+    link(from: string, to: string, follow?: boolean): void;
+    unlink(path: string): void;
+    rmdir(path: string): void;
+    symlink(target: string, linkPath: string): void;
+    readlink(path: string): string;
+    chmod(path: string, mode: number): void;
+    utimes(path: string, atimeMs: number, mtimeMs: number, now?: boolean): void;
+    lutimes(path: string, atimeMs: number, mtimeMs: number, now?: boolean): void;
+    hold?(path: string, held: boolean, open?: boolean, handle?: number, want?: number): number | undefined;
+    access?(path: string, mode: number, kind?: AccessKind, nofollow?: boolean): void;
+    create?(path: string, mode?: number, opening?: boolean): void;
+    chown?(path: string, ...rest: ChownArgs): void;
+    owners?: boolean;
+    links?: boolean;
+    readdirStat(path: string): Array<[string, SyncFsBridgeStat | null]>;
+    statfs?(path?: string): SyncFsUsage | null;
+    pread?(path: string, offset: number, length: number, version?: string): Uint8Array;
+    pwrite?(path: string, offset: number, bytes: Uint8Array, transfer?: boolean): void;
+    truncate?(path: string, size: number): void;
+    append?(path: string, bytes: Uint8Array): number;
+    identify?(): void;
+    identified?(): SyncFsBridgeStat | null;
+}
+export declare function syncError(code: string, label: string): Error & {
+    code: string;
+};
+export declare function parseSyncFsStat(json: unknown): SyncFsBridgeStat | null;

package/dist/types/realm/sync-sab-bridge.d.ts

@@ -0,0 +1,21 @@
+import { type SyncFsPosixBridge, type SyncFsResult } from './sync-fs-wire.js';
+import { type SyncSabRequestBody } from './sync-sab-wire.js';
+export interface SabPostLike {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+}
+export interface SyncSabTransport {
+    call(req: SyncSabRequestBody, timeoutMs: number, label: string, transfer?: Transferable[]): SyncFsResult;
+}
+export type AtomicsWaitLike = (typedArray: Int32Array, index: number, value: number, timeout?: number) => 'ok' | 'not-equal' | 'timed-out';
+export declare function syncCallCount(): number;
+export declare function createSyncSabTransport(sab: SharedArrayBuffer, port: SabPostLike, deps?: {
+    wait?: AtomicsWaitLike;
+    now?: () => number;
+    memory?: () => number;
+}): SyncSabTransport;
+export declare function createSyncFsSabBridge(transport: SyncSabTransport, opts?: {
+    timeoutMs?: number;
+    owners?: boolean;
+    links?: boolean;
+    changes?: SharedArrayBuffer;
+}): SyncFsPosixBridge;

package/dist/types/realm/sync-sab-responder.d.ts

@@ -0,0 +1,16 @@
+import type { WasmSyscall } from '../kernel/process.js';
+import { type SyncFsRequest, type SyncFsResult } from './sync-fs-wire.js';
+export interface SabPortLike {
+    addEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+    removeEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+}
+export interface SyncSabResponderHandle {
+    dispose(): void;
+}
+export type SyncSabDispatchRequest = SyncFsRequest | (WasmSyscall & {
+    token: string;
+});
+export interface SyncSabResponderOptions {
+    dispatch: (req: SyncSabDispatchRequest) => Promise<SyncFsResult>;
+}
+export declare function attachSyncSabResponder(port: SabPortLike, sab: SharedArrayBuffer, token: string, opts: SyncSabResponderOptions): SyncSabResponderHandle;

package/dist/types/realm/sync-sab-wire.d.ts

@@ -0,0 +1,64 @@
+import type { WasmSyscall } from '../kernel/process.js';
+import type { SyncFsRequest, SyncFsResult } from './sync-fs-wire.js';
+export declare const SAB_HEADER_I32 = 18;
+export declare const SAB_CLOCK_OFFSET: number;
+export declare const SAB_CLOCK_I64 = 3;
+export declare const SAB_HEADER_BYTES: number;
+export declare const SAB_I_STATE = 0;
+export declare const SAB_I_SEQ = 1;
+export declare const SAB_I_STATUS = 2;
+export declare const SAB_I_TOTAL = 3;
+export declare const SAB_I_CHUNK = 4;
+export declare const SAB_I_OFFSET = 5;
+export declare const SAB_I_REQ = 6;
+export declare const SAB_I_PUB = 7;
+export declare const SAB_I_SIGNALS = 8;
+export declare const SAB_I_TIMERS = 9;
+export declare const SAB_I_MEMORY = 10;
+export declare const SAB_I_TOTAL_HI = 11;
+export declare const SAB_I_OFFSET_HI = 12;
+export declare const SAB_I_KILLED = 13;
+export declare const SAB_I_ASYNC = 14;
+export declare const SAB_I_STOP = 15;
+export declare const SAB_I_BLOCKED = 16;
+export declare const SAB_I_BLOCKED_HI = 17;
+export type BlockedMask = readonly [number, number];
+export declare function loadBlocked(header: Int32Array): BlockedMask;
+export declare function storeBlocked(header: Int32Array, [low, high]: BlockedMask): void;
+export declare const anyBlocked: (mask: BlockedMask | undefined) => boolean;
+export declare function storeU53(header: Int32Array, lo: number, hi: number, value: number): void;
+export declare function loadU53(header: Int32Array, lo: number, hi: number): number;
+export declare function publishMemory(sab: SharedArrayBuffer, bytes: number): void;
+export declare const SAB_STATE_IDLE = 0;
+export declare const SAB_STATE_PENDING = 1;
+export declare const SAB_STATE_READY = 2;
+export declare const SAB_STATUS_BYTES = 1;
+export declare const SAB_STATUS_JSON = 2;
+export declare const SAB_STATUS_VOID = 3;
+export declare const SAB_STATUS_ERRNO = 4;
+export declare const SAB_DEFAULT_WINDOW_BYTES: number;
+export declare const SAB_MIN_BYTES: number;
+export declare const SYNC_SAB_REQ_MSG = "sync-sab-req";
+export declare const SYNC_SAB_NEXT_MSG = "sync-sab-next";
+export type SyncSabRequestBody = Omit<SyncFsRequest, 'token'> | WasmSyscall;
+export interface SyncSabReqMsg {
+    type: typeof SYNC_SAB_REQ_MSG;
+    id: number;
+    req: SyncSabRequestBody;
+}
+export interface SyncSabNextMsg {
+    type: typeof SYNC_SAB_NEXT_MSG;
+    id: number;
+    offset: number;
+}
+export interface SabEncodedResult {
+    status: number;
+    payload: Uint8Array;
+}
+export declare function encodeSabResult(result: SyncFsResult): SabEncodedResult;
+export declare function decodeSabResult(status: number, payload: Uint8Array): SyncFsResult;
+export interface SabViews {
+    header: Int32Array;
+    window: Uint8Array;
+}
+export declare function sabViews(sab: SharedArrayBuffer): SabViews;

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

@@ -0,0 +1,26 @@
+import type { SealedHook, SealedRequest } from './kernel/sealed.js';
+export interface SealedPort {
+    postMessage(message: unknown): void;
+}
+export interface SealedAsk {
+    id: number;
+    req: SealedRequest;
+}
+export interface SealedReply {
+    id: number;
+    reply?: object;
+    error?: string;
+}
+export interface SealedAbort {
+    id: number;
+    reason: unknown;
+}
+export declare function sealedAsker(port: SealedPort): {
+    hook: SealedHook;
+    answer(reply: SealedReply): void;
+};
+export interface SealedAnswerer {
+    handle(data: unknown): boolean;
+    close(): void;
+}
+export declare function sealedAnswerer(port: SealedPort, hook: SealedHook | undefined): SealedAnswerer;