@ai-ecoverse/slicc-kernel 1.161.0 → 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,6 +40,8 @@ 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;
@@ -51,6 +53,8 @@ export declare class OpfsFs implements KernelFs {
         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;

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<{
@@ -44,6 +90,9 @@ export declare class RemoteWatch {
     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;
@@ -80,10 +129,16 @@ 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;
@@ -106,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[];
@@ -142,6 +144,40 @@ export interface KernelFs {
         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,7 @@ 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[];

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

@@ -55,7 +55,7 @@ export declare class HeldSet extends Set<HeldPaths> {
     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;
@@ -86,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,7 @@ 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>;

package/package.json

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