@ai-ecoverse/slicc-kernel 1.132.0 → 1.133.0

package/dist/types/fs/physical-path.d.ts

@@ -5,6 +5,7 @@ export interface LinkReader {
     readlink(path: string): string;
 }
 export declare function physicalPath(fs: LinkReader, path: string): string;
+export declare function physicalLeaf(fs: LinkReader, path: string): string | undefined;
 export interface AsyncLinkReader {
     lstat(path: string): Promise<{
         isSymbolicLink?: boolean;

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

@@ -20,6 +20,7 @@ export declare const JS_MAX_THREADS = 256;
 export declare const JS_DEFAULT_THREADS = 16;
 export declare const JS_THREAD_NO_MEMORY = 256;
 export declare const JS_THREAD_CRASHED = 257;
+export declare const JS_THREAD_OWNED_FDS = 1024;
 export interface WasmProgram {
     abi?: 'emscripten' | 'wasi';
     glue: string;
@@ -117,6 +118,7 @@ export interface JsThreadStart {
     tid: number;
     port: MessagePort;
     data: unknown;
+    owned?: SharedArrayBuffer;
 }
 export type JsThreadInitMsg = Omit<JsProcessInitMsg, 'type'> & {
     type: typeof JS_THREAD_INIT;

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

@@ -147,6 +147,11 @@ export interface ContextOptions {
     lane?: SyncCall;
     strays?: JsStrays;
     thread: JsThreadContext;
+    fs?: {
+        owners: boolean;
+        links: boolean;
+    };
+    owned?: SharedArrayBuffer;
 }
 export interface Identity {
     pid: number;

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

@@ -7,6 +7,7 @@ import { type FdInfo, type JsOpenOptions, type JsStatFs, type JsWriteOptions } f
 import { type JsKernel } from './js-kernel.js';
 import type { JsRunOptions, JsRunResult } from './js-run.js';
 import type { JsSyncTty } from './js-tty.js';
+import type { JsWasi, JsWasiOptions } from './js-wasi.js';
 import type { JsWatcher, JsWatchListener, JsWatchOptions } from './js-watch.js';
 export type SyncCall = (req: SyncSabRequestBody) => SyncFsResult;
 export interface JsSyncFile {
@@ -46,6 +47,9 @@ export interface JsSyncContext {
     socketpair(): [number, number];
     pipe(): [number, number];
     open(path: string, options?: JsOpenOptions): JsSyncFile;
+    wasi: {
+        create(options?: JsWasiOptions): JsWasi;
+    };
     fs: {
         stat(path: string): SyncFsBridgeStat;
         lstat(path: string): SyncFsBridgeStat;
@@ -91,6 +95,6 @@ export declare class JsSyncKernel {
     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' | 'fs' | 'tty'> & {
+export declare function syncOps(kernel: JsSyncKernel, shared: SyncShared): Omit<JsSyncContext, 'run' | 'spawn' | 'exit' | 'kill' | 'cred' | 'setcred' | 'kernel' | 'umask' | 'fs' | 'tty' | 'wasi'> & {
     fs: Omit<JsSyncContext['fs'], 'watch'>;
 };

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

@@ -0,0 +1,47 @@
+import { type WasiFunction } from '../wasi/wasi-host.js';
+import type { SyncCall } from './js-sync.js';
+export interface JsWasiOptions {
+    args?: readonly string[];
+    env?: Readonly<Record<string, string>>;
+    preopens?: Readonly<Record<string, string>>;
+    stdio?: readonly [number, number, number];
+    returnOnExit?: boolean;
+}
+export interface JsWasi {
+    readonly imports: {
+        wasi_snapshot_preview1: Record<string, WasiFunction>;
+    };
+    readonly wasiImport: Record<string, WasiFunction>;
+    bind(memory: WebAssembly.Memory): void;
+    start(instance: WebAssembly.Instance): number;
+    initialize(instance: WebAssembly.Instance): void;
+    close(): void;
+}
+export declare class JsWasiExit extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+export interface JsWasiDeps {
+    lane: SyncCall;
+    pid: number;
+    cwd: string;
+    resolve(path: string): string;
+    fs: {
+        owners: boolean;
+        links: boolean;
+    } | undefined;
+    live: Set<JsWasi>;
+    owned: OwnedFds;
+}
+export interface OwnedFds {
+    add(fd: number): void;
+    remove(fd: number): void;
+}
+export declare function ownedFds(sab: SharedArrayBuffer | undefined): OwnedFds;
+export declare function createJsWasi(deps: JsWasiDeps, o?: JsWasiOptions): JsWasi;
+export declare function wasiFor(o: Omit<JsWasiDeps, 'live' | 'owned'> & {
+    owned: SharedArrayBuffer | undefined;
+}): {
+    create(options?: JsWasiOptions): JsWasi;
+    closeAll(): void;
+};

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

@@ -0,0 +1,55 @@
+import type { InheritedSlot } from '../kernel/children.js';
+import type { Cred, CredChange } from '../kernel/cred.js';
+import type { ForkState, ForkStream } from '../kernel/protocol.js';
+import type { SyncFsResult } from '../realm/sync-fs-wire.js';
+import type { SyncSabTransport } from '../realm/sync-sab-bridge.js';
+import type { ProcessFs, ProcessStream } from './kernel-streams.js';
+import type { HttpKernel } from './process-http.js';
+import type { SocketKernel } from './process-sockets.js';
+import type { Owner } from './realm-user.js';
+export declare function inheritedOf(r: SyncFsResult): number;
+export declare function inheritedSignals(transport: SyncSabTransport): number;
+export interface ProcessKernel {
+    spawn(file: string, argv: string[], env: Record<string, string> | null, cwd: string | null, stdio: number[], actions?: ReadonlyArray<readonly [number, number]>): number;
+    wait(pid: number, nohang: boolean, options?: number): [number, number] | number;
+    fork(state: ForkState): number;
+    kill(pid: number, sig: number): number;
+    pause(): number;
+    sigInherited(): number;
+    setpgid(pid: number, pgid: number): number;
+    setsid(): number;
+    getpgid(pid: number): number;
+    getsid(pid: number): number;
+    cred(): Cred | number;
+    setcred(change: CredChange): Cred | number;
+    tcgetpgrp(fd: number): number;
+    tcsetpgrp(fd: number, pgrp: number): number;
+    execWait(pid: number): number;
+    execve(file: string, argv: string[], env: Record<string, string> | null, cwd: string | null): number;
+    mount(source: string, target: string, fstype: string, flags: number, data: string): number;
+    umount2(target: string, flags: number): number;
+    select(read: number[], write: number[], timeoutMs: number): {
+        read: number[];
+        write: number[];
+    } | number;
+    net?: SocketKernel;
+    hostname?: string;
+    http?: HttpKernel;
+}
+export interface ProcessKernelDeps {
+    transport: SyncSabTransport;
+    owner?: Owner;
+    Fs: ProcessFs;
+    env: Record<string, string>;
+    beforeSpawn(): void;
+    afterChild(): void;
+    describeFork(): ForkStream[];
+    inherit?(actions?: ReadonlyArray<readonly [number, number]>): InheritedSlot[];
+    stdioPromoter?(): (stream: ProcessStream) => void;
+    pid?: number;
+    raise?(sig: number): void;
+    restartable?(): boolean;
+    memory?(): WebAssembly.Memory | undefined;
+    deliveries?(): number;
+}
+export declare function createProcessKernel(deps: ProcessKernelDeps): ProcessKernel;

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

@@ -0,0 +1,10 @@
+import type { InheritedSlot } from '../kernel/children.js';
+import type { DeviceMeta } from '../kernel/fd-table.js';
+import type { ForkStream, KernelStreamEntry } from '../kernel/protocol.js';
+import type { KernelStreams, ProcessFs, ProcessStream, ProcessSys } from './kernel-streams.js';
+export declare function vfsPromoter(Fs: ProcessFs, sys: ProcessSys, streams: KernelStreams, livePath: (stream: ProcessStream) => string): (stream: ProcessStream) => void;
+export declare function describeForFork(Fs: ProcessFs, sys: ProcessSys, streams: KernelStreams, livePath: (stream: ProcessStream) => string): ForkStream[];
+export declare function describeInherited(Fs: ProcessFs, sys: ProcessSys, streams: KernelStreams, livePath: (stream: ProcessStream) => string, actions?: ReadonlyArray<readonly [number, number]>): InheritedSlot[];
+export declare function deviceOfStream(stream: ProcessStream): DeviceMeta | undefined;
+export declare function placeKernelStream(Fs: ProcessFs, streams: KernelStreams, entry: KernelStreamEntry): ProcessStream;
+export declare function restoreForkedStreams(Fs: ProcessFs, streams: KernelStreams, table: readonly ForkStream[]): void;

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

@@ -0,0 +1,19 @@
+import type { HttpHead } from '../kernel/net/http-syscalls.js';
+import type { HeaderList } from '../kernel/net/transport.js';
+import type { SyncSabTransport } from '../realm/sync-sab-bridge.js';
+export interface HttpRequest {
+    url: string;
+    method?: string;
+    headers?: HeaderList;
+    body?: Uint8Array;
+}
+export interface HttpKernel {
+    request(req: HttpRequest): HttpHead;
+    read(handle: number, max: number): Uint8Array;
+    close(handle: number): void;
+}
+export declare class HttpError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function createHttpKernel(transport: SyncSabTransport): HttpKernel;

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

@@ -0,0 +1,55 @@
+import { type ForkState, type InheritedFd, type WasmProcessInitMsg } from '../kernel/protocol.js';
+import { type SabPostLike, type SyncSabTransport } from '../realm/sync-sab-bridge.js';
+import { KernelStreams, type ProcessFs, type ProcessPipeFs, type ProcessSys } from './kernel-streams.js';
+import { type ProcessKernel } from './process-children.js';
+import { type GlueSyscalls, type KernelImports } from './process-fds.js';
+import { type LockKernel } from './process-locks.js';
+import type { PtyKernel } from './process-pty.js';
+export { type ProcessFs, type ProcessStream, type ProcessSys, SyscallError, } from './kernel-streams.js';
+export declare function kernelSys(transport: SyncSabTransport): ProcessSys & PtyKernel & LockKernel;
+export declare function wireKernelFd(Fs: ProcessFs, streams: KernelStreams, entry: InheritedFd): void;
+export declare function wireKernelStdio(Fs: ProcessFs, streams: KernelStreams, sys?: ProcessSys): void;
+interface RunningModule {
+    FS: ProcessFs;
+    callMain(args: string[]): number | undefined;
+    sliccRunMain?: (args: string[]) => number | undefined;
+    sliccForkChild?: (state: ForkState & {
+        pid: number;
+    }) => number | undefined;
+    PIPEFS?: ProcessPipeFs;
+    sliccSigpipe?: () => number;
+    sliccSigMask?: (which: number) => number;
+    sliccRaise?: (sig: number) => void;
+    sliccTimerFire?: (which: number) => boolean;
+    sliccKernel?: ProcessKernel;
+    sliccSyscalls?: GlueSyscalls;
+}
+export type GlueEvaluator = (glue: string, module: object) => void;
+export declare function glueBody(glue: string): string;
+export declare function ownValue<T>(module: object, name: string): T | undefined;
+export declare const evaluateGlue: GlueEvaluator;
+export declare const EVAL_BLOCKED: string;
+export declare function identify(transport: SyncSabTransport, init: {
+    pid: number;
+    ppid?: number;
+}): {
+    pid: number;
+    ppid: number;
+};
+export declare function liveParent(imports: WebAssembly.Imports, parent: () => number, glue?: KernelImports): void;
+export declare function signalMasks(m: Pick<RunningModule, 'sliccSigMask'>): {
+    caught: number;
+    ignored: number;
+    restart: number;
+} | null;
+export declare function reportGrowth(imports: WebAssembly.Imports, publish: () => void, glue?: KernelImports): void;
+export declare function holdWhileStopped(imports: WebAssembly.Imports, header: Int32Array, glue?: KernelImports, poll?: () => void): void;
+export declare function runWasmProcess(init: WasmProcessInitMsg, port: SabPostLike, deps?: {
+    evaluate?: GlueEvaluator;
+    warn?: (message: string) => void;
+}): Promise<number>;
+interface QuitFs {
+    quit?: () => void;
+    close: (stream: unknown) => void;
+}
+export declare function quietQuit(Fs: QuitFs, quitting?: (on: boolean) => void): void;

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

@@ -0,0 +1,38 @@
+import type { SockAddr, SocketDomain } from '../kernel/socket.js';
+import type { SyncSabTransport } from '../realm/sync-sab-bridge.js';
+import { type KernelStreams, type ProcessFs, type ProcessSys } from './kernel-streams.js';
+export interface SocketKernel {
+    socket(domain: SocketDomain, nonblock: boolean, cloexec?: boolean): number;
+    socketpair(domain: SocketDomain, nonblock: boolean, cloexec?: boolean): [number, number] | number;
+    bind(fd: number, addr: SockAddr): number;
+    listen(fd: number, backlog: number): number;
+    accept(fd: number, nonblock: boolean, cloexec?: boolean): {
+        fd: number;
+        peer: SockAddr;
+    } | number;
+    connect(fd: number, addr: SockAddr): number;
+    shutdown(fd: number, how: number): number;
+    name(fd: number, peer: boolean): SockAddr | number;
+    getopt(fd: number, level: number, name: number): {
+        value: number;
+    } | number;
+    setopt(fd: number, level: number, name: number, value: number): number;
+    resolve(name: string, family?: 0 | 4 | 6): string[] | number;
+    send(fd: number, bytes: Uint8Array, flags: {
+        dontwait?: boolean;
+        nosignal?: boolean;
+    }): number;
+    recv(fd: number, max: number, flags: {
+        dontwait?: boolean;
+        peek?: boolean;
+    }): Uint8Array | number;
+}
+export interface SocketKernelDeps {
+    transport: SyncSabTransport;
+    Fs: ProcessFs;
+    sys: ProcessSys;
+    streams: KernelStreams;
+    sigpipe?: () => boolean;
+    restartable?: () => boolean;
+}
+export declare function createSocketKernel(deps: SocketKernelDeps): SocketKernel;

package/dist/types/process/realm-user.d.ts

@@ -0,0 +1,9 @@
+import type { Cred } from '../kernel/cred.js';
+import type { ProcessFs } from './kernel-streams.js';
+export interface Owner {
+    uid: number;
+    gid: number;
+}
+export declare const LEGACY_OWNER: Readonly<Owner>;
+export declare function credAbi(glue: string): boolean;
+export declare function ownByCaller(Fs: ProcessFs, cred?: Readonly<Cred>, abi?: boolean): Owner;

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

@@ -43,6 +43,8 @@ export declare class WasiFds {
         flags?: number;
         device?: DeviceMeta;
     }>, root?: boolean): void;
+    adoptCopy(fd: number): number;
+    preopenAt(path: string, name: string): number;
     private preopens;
     find(fd: number): WasiEntry | undefined;
     private shared;

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

@@ -34,6 +34,7 @@ export interface WasiHostOptions {
         cloexec: readonly number[];
     };
     preopenRoot?: boolean;
+    bare?: boolean;
 }
 export type WasiFunction = (...args: never[]) => number | undefined;
 export declare class WasiHost {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-kernel",
-  "version": "1.132.0",
+  "version": "1.133.0",
   "description": "SLICC's wasm-realm kernel: run Emscripten programs in the browser against OPFS, with fork, spawn, pipes and waitpid",
   "type": "module",
   "license": "Apache-2.0",
@@ -63,16 +63,16 @@
     "format": "biome check --write ."
   },
   "devDependencies": {
-    "@ai-ecoverse/py-numpy": "2.3.2-12",
+    "@ai-ecoverse/py-numpy": "2.5.4-1",
     "@ai-ecoverse/slicc-node": "2.5.1",
     "@ai-ecoverse/slicc-scrub": "1.0.0",
-    "@ai-ecoverse/slicc-shared-web": "1.24.2",
+    "@ai-ecoverse/slicc-shared-web": "1.25.0",
     "@ai-ecoverse/wasi-cargo": "0.99.0-3",
     "@ai-ecoverse/wasi-pnpm": "12.9.1-15",
     "@ai-ecoverse/wasi-ripgrep": "15.2.0-5",
     "@ai-ecoverse/wasi-rustc": "1.98.1-6",
     "@ai-ecoverse/wasi-zig": "0.16.0-17",
-    "@ai-ecoverse/wasix-python": "3.14.2-28",
+    "@ai-ecoverse/wasix-python": "3.15.0-2",
     "@ai-ecoverse/wasm-bash": "5.3.0-20",
     "@ai-ecoverse/wasm-coreutils": "9.12.0-10",
     "@ai-ecoverse/wasm-curl": "8.22.0-7",
@@ -90,6 +90,7 @@
     "fake-indexeddb": "6.2.5",
     "lefthook": "2.2.1",
     "monocart-coverage-reports": "2.13.2",
+    "pg-gateway": "0.3.0-beta.4",
     "playwright-core": "1.64.0",
     "semantic-release": "25.0.9",
     "typescript": "7.0.2",