@ai-ecoverse/slicc-kernel 1.118.1 → 1.119.1

package/dist/types/fs/opfs.d.ts

@@ -30,6 +30,7 @@ export declare class OpfsFs implements KernelFs {
     private readonly mounts;
     private readonly locks;
     private readonly lockPrefix;
+    readonly rootName: string | undefined;
     constructor(root: FileSystemDirectoryHandle, meta?: MetaStore, channel?: string, options?: {
         ranged?: boolean;
         locks?: LockManagerLike | null;

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

@@ -76,6 +76,7 @@ export interface KernelFs {
     readlink(path: string): Promise<string>;
     realpath?(path: string, follow: boolean): Promise<string>;
     createExclusive?(path: string, owner?: NewOwner): Promise<void>;
+    readonly rootName?: string;
     chown?(path: string, change: OwnerChange): Promise<void>;
     trackOwners?(): void;
     crossings?(mounted: (path: string) => boolean): void;

package/dist/types/kernel/host-ops.d.ts

@@ -1,5 +1,6 @@
 import type { SyncFsResult } from '../realm/sync-fs-wire.js';
-import { type FlockKind, type LockKind, type LockTable } from './locks.js';
+import type { KernelLocks } from './lock-service.js';
+import { type FlockKind, type LockKind } from './locks.js';
 export interface LockTarget {
     path?: string;
     fd?: number;
@@ -96,7 +97,7 @@ export interface HostOpsContext {
         key: string;
         owner: object;
     }>;
-    locks: LockTable | undefined;
+    locks: KernelLocks | undefined;
     ops: AsyncOps;
     blocking: () => AbortSignal;
     valid: (req: {

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

@@ -10,7 +10,7 @@ import { type Cred } from './cred.js';
 import { type FdTable, type OpenFile } from './fd-table.js';
 import type { FifoTable } from './fifo.js';
 import type { JobTable } from './jobs.js';
-import type { LockTable } from './locks.js';
+import type { KernelLocks } from './lock-service.js';
 import type { HttpHandles } from './net/http-syscalls.js';
 import type { Resolver } from './net/resolver.js';
 import type { MountLine, ProcessListing } from './proc-info.js';
@@ -85,7 +85,7 @@ export interface SpawnWasmOptions {
     ptys?: PtyTable;
     net?: LoopbackNet;
     http?: HttpHandles;
-    locks?: LockTable;
+    locks?: KernelLocks;
     fifos?: FifoTable;
     sems?: SemTable;
     onReap?: (pid: number) => void;

package/dist/types/kernel/lock-service.d.ts

@@ -0,0 +1,92 @@
+import { type LockManagerLike } from '../fs/remote.js';
+import { type FlockKind, type LockKind, type RecordLock } from './locks.js';
+export declare const PRUNE_MS = 1000;
+export declare const LOCKS_PROTOCOL = "v1";
+type Range = {
+    start: number;
+    end: number;
+};
+type Want = {
+    key: string;
+    kind: LockKind;
+} & Range;
+export interface KernelLocks {
+    readonly flocks: {
+        set(key: string, owner: object, kind: FlockKind | 'unlock'): boolean | Promise<boolean>;
+        wait(key: string, owner: object, kind: FlockKind, blocking: () => AbortSignal): Promise<void>;
+        drop(owner: object): void;
+    };
+    holder(key: string, owner: number, want: Want): RecordLock | undefined | Promise<RecordLock | undefined>;
+    set(key: string, owner: number, kind: LockKind | 'unlock', start: number, end: number): boolean | Promise<boolean>;
+    wait(key: string, owner: number, kind: LockKind, range: Range, blocking: () => AbortSignal): Promise<void>;
+    holds(owner: number): boolean;
+    dropFile(key: string, owner: number): void;
+    release(pid: number): void;
+    lock(pid: number, path: string, exclusive: boolean, fd: number): boolean;
+    unlock(pid: number, path: string): void;
+    closed(pid: number, fd: number): void;
+}
+export interface LockServiceOptions {
+    root: string;
+    locks: LockManagerLike & {
+        request(name: string, options: {
+            ifAvailable: true;
+        }, cb: (lock: unknown) => Promise<void>): Promise<unknown>;
+    };
+    channel?: (name: string) => BroadcastChannel;
+}
+export declare class LockService implements KernelLocks {
+    readonly kernel: `${string}-${string}-${string}-${string}-${string}`;
+    private table;
+    private leader;
+    private readonly role;
+    private readonly channel;
+    private readonly locks;
+    private readonly root;
+    private readonly pending;
+    private next;
+    private readonly owners;
+    private readonly ownerOf;
+    private nextRemote;
+    private readonly tokens;
+    private readonly flockIds;
+    private readonly flockOwners;
+    private nextFlock;
+    private readonly granted;
+    private readonly waiting;
+    private settled;
+    private pruner;
+    readonly flocks: KernelLocks['flocks'];
+    constructor(options: LockServiceOptions);
+    private aliveOf;
+    private elect;
+    private lead;
+    private receive;
+    private answered;
+    private request;
+    private ownerFor;
+    private tokenFor;
+    private serve;
+    private signalOf;
+    private blockFor;
+    private watchRemotes;
+    prune(): Promise<void>;
+    private reassert;
+    private adopt;
+    private flockIdOf;
+    private ask;
+    holder(key: string, owner: number, want: Want): Promise<RecordLock | undefined>;
+    set(key: string, owner: number, kind: LockKind | 'unlock', start: number, end: number): Promise<boolean>;
+    wait(key: string, owner: number, kind: LockKind, range: Range, blocking: () => AbortSignal): Promise<void>;
+    holds(owner: number): boolean;
+    dropFile(key: string, owner: number): void;
+    release(pid: number): void;
+    private flockSet;
+    private flockWait;
+    private flockDrop;
+    lock(pid: number, path: string, exclusive: boolean, fd: number): boolean;
+    unlock(pid: number, path: string): void;
+    closed(pid: number, fd: number): void;
+}
+export declare function kernelLocks(root: string | undefined): KernelLocks;
+export {};

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

@@ -23,6 +23,7 @@ export declare class FlockTable {
     private free;
     set(key: string, owner: object, kind: FlockKind | 'unlock'): boolean;
     wait(key: string, owner: object, kind: FlockKind, blocking: () => AbortSignal): Promise<void>;
+    entries(): Array<[string, object, FlockKind]>;
     drop(owner: object): void;
 }
 export declare class LockTable {
@@ -41,6 +42,7 @@ export declare class LockTable {
     private changed;
     private wake;
     private store;
+    entries(): Array<[string, RecordLock[]]>;
     holds(owner: number): boolean;
     dropFile(key: string, owner: number): void;
     lock(pid: number, path: string, exclusive: boolean, fd: number): boolean;

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

@@ -14,7 +14,7 @@ import { type DeviceAccess, type FdTable, type HeldMeta, type KernelFdKind, type
 import type { FifoTable } from './fifo.js';
 import { type HostSyscall } from './host-ops.js';
 import type { JobTable } from './jobs.js';
-import type { LockTable } from './locks.js';
+import type { KernelLocks } from './lock-service.js';
 import { type HttpHandles, type HttpSyscall } from './net/http-syscalls.js';
 import { Resolver } from './net/resolver.js';
 import type { MountLine, ProcessListing } from './proc-info.js';
@@ -400,7 +400,7 @@ export interface WasmProcessOptions {
     ptys?: PtyTable;
     net?: LoopbackNet;
     http?: HttpHandles;
-    locks?: LockTable;
+    locks?: KernelLocks;
     fifos?: FifoTable;
     sems?: SemTable;
     resolver?: Resolver;

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

@@ -24,6 +24,7 @@ export interface LockDeps {
     kernel: LockKernel;
     flush(): void;
 }
+export declare const lockPromoters: WeakMap<object, () => (stream: ProcessStream) => 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/wasi/slicc-lock.d.ts

@@ -23,7 +23,7 @@ export interface LockHost {
     file(fd: number): LockedFile;
     flush(file: LockedFile): void;
     locked(): void;
-    promote(fd: number): void;
+    promote(fd: number, moved?: boolean): void;
     calls: LockCalls;
 }
 export declare function lockImports(host: LockHost): Record<string, WasiFunction>;

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

@@ -77,7 +77,7 @@ export declare class WasiFds {
     dup(fd: number, min: number, cloexec: boolean): number;
     pipe(): [number, number];
     chdir(path: string): void;
-    promote(fd: number): void;
+    promote(fd: number, moved?: boolean): void;
     promoteFiles(only?: FileBuffer): void;
     snapshot(): WasiForkFd[];
     restore(fds: readonly WasiForkFd[], cloexec: readonly number[]): void;
@@ -109,6 +109,7 @@ export declare class WasiFds {
     unlinking(path: string, linked?: SyncFsBridgeStat): void;
     unlinked(path: string, linked?: SyncFsBridgeStat): void;
     private openedIno;
+    moved(fd: number): boolean;
     private inoOf;
     private survives;
     private detach;

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

@@ -44,6 +44,7 @@ export declare class FileBuffer {
 export declare class LocalFile {
     offset: number;
     refs: number;
+    ino: number | undefined;
     readonly buffer: FileBuffer;
     readonly readable: boolean;
     readonly writable: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-kernel",
-  "version": "1.118.1",
+  "version": "1.119.1",
   "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",