@ai-ecoverse/slicc-kernel 1.160.3 → 1.162.0

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

@@ -1,6 +1,6 @@
 import { type MetaStore } from './meta.js';
-import { type LockManagerLike, type RemoteListener } from './remote.js';
-import { type CopyOptions, type FsStat, type KernelFs, type NewOwner, type OwnerChange, type Peers, type Perm, type PwriteOptions } from './types.js';
+import { type KeepHandlers, type LockManagerLike, type RemoteListener } from './remote.js';
+import { type CopyOptions, type FsStat, type KernelFs, type NewOwner, type OwnerChange, type PeerKeeps, type Peers, type Perm, type PwriteOptions } from './types.js';
 export type OpfsOp = 'lookup' | 'read' | 'write' | 'commit' | 'sidecar';
 export declare function translate(err: unknown, path: string, op?: OpfsOp, mapped?: boolean): Error;
 export interface WriteSession {
@@ -40,10 +40,22 @@ export declare class OpfsFs implements KernelFs {
     });
     private changed;
     fileId(path: string): Promise<string>;
+    bindId(path: string): Promise<string | undefined>;
+    private assignId;
     private heldUnder;
     heldBy(held: (dir: string) => readonly string[]): void;
     private pinHeld;
     remoteChanges(listener: RemoteListener): () => void;
+    announceHolds(add: ReadonlyArray<[string, string | undefined]>, drop: readonly string[], wait: boolean): Promise<void>;
+    holdCounts(): {
+        mine: number;
+        peers: number;
+        sent: number;
+        held: string[];
+    } | undefined;
+    peerKeeps(): PeerKeeps | undefined;
+    servePeerKeeps(instance: string, handlers: KeepHandlers): void;
+    rehold(from: string, to: string): void;
     announceWatch(paths: readonly string[]): Promise<void>;
     private committed;
     private counted;

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

@@ -19,6 +19,52 @@ export declare const MOURN_TRIES = 5;
 export declare const MOURN_RETRY_MS = 100;
 export declare const RENAME_ACK_MAX_MS = 10000;
 export declare const ANNOUNCE_POLL_MS = 20;
+interface WatchMessage {
+    hello?: string;
+    here?: string;
+    to?: string;
+    tab?: string;
+    seq?: number;
+    paths?: string[];
+    ack?: number;
+    from?: string;
+    changed?: string[];
+    renames?: true;
+    keeps?: true;
+    renaming?: PeerRename;
+    renamed?: string;
+    flushing?: string;
+    holds?: {
+        add: Array<[string, string | undefined]>;
+        drop: string[];
+        instance?: string;
+    };
+    keeping?: {
+        paths: string[];
+    };
+    kept?: {
+        items: PeerKept[];
+        paths?: string[];
+    };
+    instance?: string;
+}
+export interface PeerKept {
+    path: string;
+    hidden: string | undefined;
+    fid: string | undefined;
+    undo?: string;
+}
+export interface PeerHolder {
+    tab: string;
+    path: string;
+    fid: string | undefined;
+    instance: string | undefined;
+}
+export interface KeepHandlers {
+    keeping(tab: string, paths: readonly string[]): Promise<void>;
+    kept(tab: string, items: readonly PeerKept[], paths: readonly string[]): Promise<void>;
+    left(tab: string): void;
+}
 export interface LockManagerLike {
     request(name: string, callback: () => Promise<void>): Promise<unknown>;
     query(): Promise<{
@@ -39,6 +85,14 @@ export declare class RemoteWatch {
     private readonly mourned;
     private readonly others;
     private readonly union;
+    private readonly myHolds;
+    private readonly peerHolds;
+    private holdsSent;
+    private readonly silent;
+    private readonly holders;
+    private readonly instances;
+    instance: string | undefined;
+    keeps: KeepHandlers | undefined;
     private readonly listeners;
     private readonly waiting;
     private readonly locks;
@@ -75,6 +129,26 @@ export declare class RemoteWatch {
     private greeted;
     private heard;
     private announced;
+    private holdsHeard;
+    private readonly keepChains;
+    private keepAsked;
+    private keepOne;
+    private heldBy;
+    hold(add: ReadonlyArray<[string, string | undefined]>, drop: readonly string[], wait: boolean): Promise<void>;
+    rehold(from: string, to: string): void;
+    private sendHolds;
+    heldWithin(target: string): PeerHolder[];
+    ask(to: string, body: Pick<WatchMessage, 'keeping' | 'kept'>, cap: number): Promise<boolean>;
+    peerHeld(path: string): Array<{
+        tab: string;
+        fid: string | undefined;
+    }>;
+    peerHeldPaths(): string[];
+    holdCounts(): {
+        mine: number;
+        peers: number;
+        sent: number;
+    };
     private acked;
     private rebuild;
     prune(): Promise<void>;
@@ -87,3 +161,4 @@ export declare class RemoteWatch {
     emit(change: RemoteChange): void;
     listen(listener: RemoteListener): () => void;
 }
+export {};

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

@@ -38,6 +38,7 @@ export interface NewOwner extends Owner {
     parents?: number;
     socket?: boolean;
     fifo?: boolean;
+    existing?: true;
 }
 export interface CopyOptions {
     exclusive: boolean;
@@ -94,6 +95,7 @@ export interface KernelFs {
     onPeer?(settle: () => Promise<void>): void;
     heldBy?(held: (dir: string) => readonly string[]): void;
     fileId?(path: string): Promise<string>;
+    bindId?(path: string): Promise<string | undefined>;
     remoteChanges?(listener: (change: {
         paths: readonly string[];
         trees?: readonly string[];
@@ -134,6 +136,48 @@ export interface KernelFs {
     };
     opfsOps?(): number;
     fileIdWrites?(): number;
+    announceHolds?(add: ReadonlyArray<[string, string | undefined]>, drop: readonly string[], wait: boolean): Promise<void>;
+    holdCounts?(): {
+        mine: number;
+        peers: number;
+        sent: number;
+        held: string[];
+    } | undefined;
+    rehold?(from: string, to: string): void;
+    peerKeeps?(): PeerKeeps | undefined;
+    servePeerKeeps?(instance: string, handlers: {
+        keeping(tab: string, paths: readonly string[]): Promise<void>;
+        kept(tab: string, items: ReadonlyArray<{
+            path: string;
+            hidden: string | undefined;
+            fid: string | undefined;
+            undo?: string;
+        }>, paths: readonly string[]): Promise<void>;
+        left(tab: string): void;
+    }): void;
+}
+export interface PeerKeeps {
+    shared(): boolean;
+    heldWithin(path: string): Array<{
+        tab: string;
+        path: string;
+        fid: string | undefined;
+        instance: string | undefined;
+    }>;
+    ask(to: string, body: {
+        keeping?: {
+            paths: string[];
+        };
+        kept?: {
+            items: Array<{
+                path: string;
+                hidden: string | undefined;
+                fid: string | undefined;
+                undo?: string;
+            }>;
+            paths?: string[];
+        };
+    }, cap: number): Promise<boolean>;
 }
 export interface PwriteOptions {
     create?: false;

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

@@ -1,4 +1,4 @@
-import { type KernelFs, type NewOwner } from './types.js';
+import { type KernelFs, type NewOwner, type PeerKeeps } from './types.js';
 export declare const UNLINKED_DIR = ".slicc-unlinked";
 export interface Replacements {
     settled(path: string): Promise<void>;
@@ -50,6 +50,13 @@ export declare function pidOwner(proc: {
     kill(pid: number, signal: number): unknown;
 }): UnlinkOwner;
 export declare function webLocks(): UnlinkLocks | undefined;
+export interface PeerKept {
+    whole: boolean;
+    undoing<T>(op: () => Promise<T>): Promise<T>;
+}
+export declare const PEER_RM_MS = 1000;
+export declare const PEER_RENAME_MS = 10000;
+export declare const PEER_GATE_MS: number;
 export declare class PathGate {
     private readonly tails;
     acquire(path: string): Promise<() => void>;
@@ -78,12 +85,14 @@ export declare class UnlinkedKeeper {
     private readonly links;
     private readonly linked;
     private readonly dirOwner;
+    private readonly peers;
     constructor(fs: KernelFs, holders: Iterable<UnlinkHolder>, rootOf: (path: string) => string, options?: {
         locks?: UnlinkLocks | undefined;
         busy?: (path: string) => boolean;
         owner?: UnlinkOwner | undefined;
         dirOwner?: NewOwner;
         marks?: PathMarks;
+        peers?: PeerKeeps | undefined;
     });
     private serial;
     wrap(fs?: KernelFs): KernelFs;
@@ -98,6 +107,17 @@ export declare class UnlinkedKeeper {
     pin(target: string, gated?: () => void, sealed?: () => void): Promise<Pinned>;
     private keepAside;
     private present;
+    get id(): string;
+    adopt(hidden: string, refs: number): KeptFile;
+    peerKeep(target: string, over: boolean, valid?: () => Promise<boolean>): Promise<PeerKept>;
+    private setAside;
+    private undoing;
+    removable(target: string, options?: {
+        recursive?: boolean;
+    }): Promise<boolean>;
+    renamable(source: string, target: string): Promise<boolean>;
+    private asideFor;
+    private hideFor;
     private keptFile;
     private hide;
     closed(path: string): void;

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

@@ -101,7 +101,8 @@ export interface SpawnWasmOptions {
         now: number;
         renames: Array<[string, string]>;
     };
-    fileId?: (path: string) => Promise<string> | undefined;
+    fileId?: (path: string) => Promise<string | undefined> | undefined;
+    announceHold?: (path: string, fid: string | undefined, created: boolean) => Promise<void> | undefined;
     renameSeq?: (from: string, to: string) => number | undefined;
     mounts?: () => MountLine[];
     mount?: WasmProcessOptions['mount'];

package/dist/types/kernel/proc-info.d.ts

@@ -56,6 +56,12 @@ export interface ProcessListing {
     cwdChecks?: number;
     staleFds?: number;
     fileIds?: number;
+    holds?: {
+        mine: number;
+        peers: number;
+        sent: number;
+        held?: readonly string[];
+    };
     renameAcks?: {
         acks: number;
         busy: number;

package/dist/types/launcher.d.ts

@@ -436,6 +436,11 @@ export declare class Launcher {
     fsFor(tag: string | undefined): KernelFs;
     isWriter(tags: readonly string[] | undefined, base?: number): boolean;
     private stackFor;
+    private readonly peerGates;
+    private peerOptions;
+    private peerKept;
+    private unadopt;
+    private adoptKept;
     private rootFileId;
     private flushingPeers;
     private rewritten;

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

@@ -51,10 +51,11 @@ interface Mount extends MountEntry {
 export declare function parseSize(text: string): number;
 export declare class HeldSet extends Set<HeldPaths> {
     private readonly idle;
-    constructor(idle: (path: string) => void);
+    private readonly moved;
+    constructor(idle: (path: string) => void, moved?: (from: string, to: string) => void);
     add(holds: HeldPaths): this;
     doubt(paths: readonly string[], over?: string): void;
-    bindIds(id: (path: string) => Promise<string> | undefined): Promise<void>;
+    bindIds(id: (path: string) => Promise<string | undefined> | undefined): Promise<void>;
     delete(holds: HeldPaths): boolean;
 }
 export declare function heldUnder(held: Iterable<Map<string, number>>, target: string): boolean;
@@ -72,6 +73,7 @@ export declare class HeldPaths extends Map<string, number> implements UnlinkHold
     private readonly doubted;
     private doubts;
     onIdle?: (path: string) => void;
+    onMoved?: (from: string, to: string) => void;
     keyOf(path: string): string;
     keptAt(path: string): KeptFile | undefined;
     holding(path: string): boolean;
@@ -84,13 +86,16 @@ export declare class HeldPaths extends Map<string, number> implements UnlinkHold
         fid?: string;
         doubt: number;
     } | undefined;
-    bindIds(id: (path: string) => Promise<string> | undefined): Promise<void>;
+    bindIds(id: (path: string) => Promise<string | undefined> | undefined): Promise<void>;
     trust(handle: number, doubt: number): void;
     pathOf(handle: number): string | undefined;
     keptFor(handle: number): KeptFile | undefined;
     holdsHandle(handle: number): boolean;
     keeps(hidden: string): boolean;
+    boundAt(path: string, fid: string | undefined): number[];
+    keepBound(ids: readonly number[], path: string, file: KeptFile): void;
     keep(path: string, file: KeptFile): void;
+    unkeepAt(path: string, hidden: string): void;
     unkeep(path: string, file: KeptFile): void;
     private letGo;
     releaseAll(): void;

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

@@ -18,7 +18,8 @@ export interface SyncFsTokenEntry {
         fid?: string;
         doubt: number;
     } | undefined;
-    fileId?: (path: string) => Promise<string> | undefined;
+    fileId?: (path: string) => Promise<string | undefined> | undefined;
+    announceHold?: (path: string, fid: string | undefined, created: boolean) => Promise<void> | undefined;
     trust?: (handle: number, doubt: number) => void;
     gate?: <T>(path: string, op: () => Promise<T>) => Promise<T>;
     unlinked?: (path: string) => KeptFile | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-kernel",
-  "version": "1.160.3",
+  "version": "1.162.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",
@@ -64,7 +64,7 @@
   },
   "devDependencies": {
     "@ai-ecoverse/py-numpy": "2.5.4-4",
-    "@ai-ecoverse/slicc-cdp": "1.41.6",
+    "@ai-ecoverse/slicc-cdp": "1.41.8",
     "@ai-ecoverse/slicc-node": "2.5.2",
     "@ai-ecoverse/slicc-scrub": "1.1.0",
     "@ai-ecoverse/slicc-shared-web": "2.12.1",