@ai-ecoverse/slicc-kernel 1.118.0 → 1.119.0

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';
@@ -342,6 +342,7 @@ export interface FdInfo {
     access?: DeviceAccess;
     name?: string;
     terminal?: string;
+    fifo?: string;
 }
 export declare function isWasmSyscall(req: object): req is WasmSyscall;
 export declare const DEFAULT_UMASK = 18;
@@ -399,7 +400,7 @@ export interface WasmProcessOptions {
     ptys?: PtyTable;
     net?: LoopbackNet;
     http?: HttpHandles;
-    locks?: LockTable;
+    locks?: KernelLocks;
     fifos?: FifoTable;
     sems?: SemTable;
     resolver?: Resolver;

package/package.json

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