@ai-ecoverse/slicc-kernel 1.102.5 → 1.103.0

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

@@ -0,0 +1,63 @@
+import type { BlockedMask } from '../../realm/sync-sab-wire.js';
+import type { WasiForkFd } from './wasi-fds.js';
+import type { WasiMemory } from './wasi-memory.js';
+import type { WasiSignalState } from './wasi-signals.js';
+export interface WasiForkState {
+    asyncifyData: number;
+    globals: Array<[string, number]>;
+    fds: WasiForkFd[];
+    cloexec: number[];
+    cwd: string;
+    shared?: true;
+    setjmps?: WasiSetjmps;
+    signals?: WasiSignalState;
+    blocked?: BlockedMask;
+    tls?: Array<[number, number]>;
+    modules?: Record<string, WebAssembly.Module>;
+    entry?: ThreadEntry;
+}
+export interface ThreadEntry {
+    tid: number;
+    arg: number;
+    low: number;
+}
+export interface WasiSetjmps {
+    next: number;
+    snapshots: Array<[number, Snapshot]>;
+}
+interface Snapshot {
+    frames: Uint8Array;
+    globals: Array<[string, number]>;
+}
+export declare function reseatTls(exports: WebAssembly.Exports, bytes: (at: number, length: number) => Uint8Array): void;
+export declare class AsyncifyDriver {
+    private exports;
+    private stackUpper;
+    private linked;
+    private pending;
+    private answer;
+    private readonly snapshots;
+    private nextSnapshot;
+    private readonly mem;
+    constructor(mem: WasiMemory);
+    useStack(pointer: WebAssembly.Global, low: number): void;
+    private threadStack;
+    useThreadStack(pointer: WebAssembly.Global, low: number): void;
+    bind(exports: WebAssembly.Exports): void;
+    get supported(): boolean;
+    get idle(): boolean;
+    resume(): boolean;
+    setjmps(): WasiSetjmps;
+    startChild(state: WasiForkState): void;
+    rewound(): number | undefined;
+    fork(fork: (asyncifyData: number, globals: Array<[string, number]>, sp: number) => number): number;
+    checkpoint(snapPtr: number, retPtr: number): number;
+    restore(snapPtr: number, val: bigint): number;
+    private stackGlobal;
+    private stackPointer;
+    private globals;
+    private dataPointer;
+    private unwind;
+    private restoreGlobals;
+}
+export {};

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

@@ -0,0 +1,108 @@
+import { type DylinkInfo } from './dylink.js';
+import { type Scalar, Trampolines } from './wasix-trampoline.js';
+import { FuncTypes } from './wasm-functypes.js';
+export declare const TABLE_BASE = 1;
+export declare const STACK_SIZE: number;
+export type LinkRecord = {
+    kind: 'load';
+    handle: number;
+    path: string;
+    memoryBase: number;
+    tableBase: number;
+    needed?: number[];
+} | {
+    kind: 'slot';
+    index: number;
+    handle: number;
+    name: string;
+} | {
+    kind: 'closure';
+    index: number;
+} | {
+    kind: 'closure-free';
+    index: number;
+} | {
+    kind: 'closure-prepare';
+    index: number;
+    backing: number;
+    userData: number;
+    params: Scalar[];
+    results: Scalar[];
+};
+export interface LinkerHost {
+    read(path: string): Uint8Array<ArrayBuffer> | undefined;
+    hostImports(module: WebAssembly.Module): WebAssembly.Imports;
+    real?(path: string): string;
+}
+export declare class DlError extends Error {
+}
+export declare class WasixLinker {
+    readonly table: WebAssembly.Table;
+    readonly stackPointer: WebAssembly.Global;
+    readonly memoryBase: number;
+    readonly stackLow: number;
+    readonly stackHigh: number;
+    private readonly cLongjmp;
+    private readonly cppException;
+    private main;
+    private readonly modules;
+    forkedTls: Map<number, number> | undefined;
+    private readonly byPath;
+    private mainGot;
+    private readonly slots;
+    private nextHandle;
+    publisher: ((record: LinkRecord) => void) | undefined;
+    indices: {
+        reserve(floor: number, size: number): number;
+        load(floor: number, size: number): {
+            base: number;
+            handle: number;
+        };
+        lock(): void;
+        unlock(): void;
+        allocate(floor: number): number;
+        free(index: number): void;
+    } | undefined;
+    types: FuncTypes;
+    readonly trampolines: Trampolines;
+    private readonly memory;
+    private readonly host;
+    constructor(memory: WebAssembly.Memory, mainInfo: DylinkInfo, host: LinkerHost, thread?: boolean);
+    mainImports(module: WebAssembly.Module): Record<string, Record<string, WebAssembly.ImportValue>>;
+    bindMainGot(): void;
+    bindMain(instance: WebAssembly.Instance, relocate: boolean): void;
+    mainPath: string | undefined;
+    private isMain;
+    open(name: string, cwd: string, ldPath: readonly string[]): number;
+    symbol(handle: number, name: string): number;
+    invalid(handle: number): boolean;
+    cache: Readonly<Record<string, WebAssembly.Module>> | undefined;
+    compiled(): Record<string, WebAssembly.Module>;
+    allocateClosure(): number;
+    freeClosure(index: number): void;
+    private readonly live;
+    prepareClosure(record: Omit<Extract<LinkRecord, {
+        kind: 'closure-prepare';
+    }>, 'kind'>): void;
+    private install;
+    private reserveLoad;
+    private reserve;
+    tlsBases(): Array<[number, number]>;
+    private carryTls;
+    replay(record: LinkRecord): void;
+    private moduleAt;
+    private module;
+    private locate;
+    private load;
+    private instantiate;
+    private functionImport;
+    private addressOrNull;
+    private slotOrNull;
+    private find;
+    private findIn;
+    private baseOf;
+    private indexed;
+    private indexTable;
+    private slot;
+    private allocate;
+}

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

@@ -0,0 +1,9 @@
+import type { SockAddr } from '../../kernel/socket.js';
+import type { WasiFunction, WasiHost } from './wasi-host.js';
+export declare function readAddr(view: DataView, ptr: number): SockAddr;
+export declare function writeAddr(view: DataView, ptr: number, addr: SockAddr | undefined): void;
+export declare function datagramCalls(host: WasiHost): {
+    recvFrom(fd: number, nonblock: boolean, iovs: number, n: number, riflags: number, outLen: number, outFlags: number, outAddr: number): number;
+    sendTo(fd: number, nonblock: boolean, iovs: number, n: number, addr: number, out: number): 0;
+};
+export declare function wasixSocketImports(host: WasiHost, preview1: Record<string, WasiFunction>): Record<string, WasiFunction>;

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;