@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.1

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

@@ -0,0 +1,41 @@
+import type { RemoteChange } from './remote.js';
+import { type KernelFs, type UsersMode } from './types.js';
+import type { FsWatchers } from './watch.js';
+export declare const ATTEST_MAX: number;
+export interface AttestedDir {
+    path: string;
+    uid: number;
+    gid: number;
+    mode: number;
+}
+export interface Attestation {
+    path: string;
+    bytes: Uint8Array;
+    uid: number;
+    gid: number;
+    mode: number;
+    ino: number;
+    mtimeMs: number;
+    sha256: string;
+    users: UsersMode;
+    onRootFs: boolean;
+    parents: AttestedDir[];
+}
+export interface AttestContext {
+    users: UsersMode;
+    mounts: readonly string[];
+}
+export declare function attest(fs: KernelFs, asked: string, o: AttestContext): Promise<Attestation>;
+export declare const WATCH_DEBOUNCE_MS = 50;
+export interface RemoteFs {
+    remoteChanges?(listener: (change: RemoteChange) => void): () => void;
+    announceWatch?(paths: readonly string[]): Promise<void>;
+}
+export declare class FileWatches {
+    private readonly live;
+    private readonly local;
+    private readonly remote;
+    constructor(local: FsWatchers, remote: RemoteFs);
+    private announce;
+    watch(paths: readonly string[], notify: (path: string) => void): Promise<() => void>;
+}

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

@@ -0,0 +1,19 @@
+export declare const CHANGES_BYTES: number;
+export declare function changeHash(path: string): number;
+export declare class FileChanges {
+    readonly sab: SharedArrayBuffer;
+    private readonly view;
+    constructor(sab?: SharedArrayBuffer);
+    dirtied(delta: number): void;
+    publish(...paths: string[]): void;
+}
+export declare class ChangeView {
+    private readonly view;
+    constructor(sab: SharedArrayBuffer);
+    now(): number;
+    clean(): boolean;
+    changedSince(seen: number, path: string): {
+        now: number;
+        changed: boolean;
+    };
+}

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

@@ -0,0 +1,4 @@
+import { type KernelFs } from './types.js';
+export declare function followLinks(fs: KernelFs, path: string): Promise<string>;
+export type UserCommandDir = (dir: string) => Promise<ReadonlySet<string> | undefined>;
+export declare function withCommandDirs(fs: KernelFs, names: () => Promise<ReadonlySet<string>>, userDir?: UserCommandDir, owners?: boolean): KernelFs;

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

@@ -0,0 +1,64 @@
+import type { Cred } from '../kernel/cred.js';
+import { type AccessOptions, type Walked } from './access.js';
+import { type FsStat, type KernelFs, type Perm } from './types.js';
+export interface Denial {
+    pid: number;
+    uid: number;
+    op: string;
+    path: string;
+    errno: string;
+    tag?: string;
+    expected?: string;
+    actual?: string;
+}
+export type DenialHook = (denial: Denial) => void;
+export declare const MAX_DENIAL_KEYS = 10000;
+export declare class Dac {
+    readonly mode: 'report' | 'enforce';
+    private readonly hook;
+    private readonly log;
+    private readonly seen;
+    private suppressed;
+    tagOf: (pid: number) => string | undefined;
+    constructor(mode: 'report' | 'enforce', hook?: DenialHook, log?: (line: string) => void);
+    get enforcing(): boolean;
+    denied(given: Denial): void;
+    private note;
+}
+export declare class Created {
+    private readonly paths;
+    add(path: string): void;
+    take(path: string): boolean;
+}
+export interface Guard {
+    fs: KernelFs;
+    cred: Readonly<Cred>;
+    pid: number;
+    dac: Dac;
+    tag?: string | undefined;
+    links?: number | undefined;
+}
+export declare function deny(g: Guard, op: string, path: string, errno?: string): void;
+export declare const TTY_MODE = 400;
+export declare function ttyOpenable(g: Guard | undefined, tty: {
+    name?: string;
+    owner?: Perm;
+}): void;
+export declare function need(g: Guard, op: string, path: string, want: number, options?: AccessOptions, shown?: string): Promise<Walked>;
+export declare function inParent(g: Guard, op: string, path: string, old?: boolean | 'replaced'): Promise<void>;
+export declare function makeIn(g: Guard, op: string, path: string): Promise<void>;
+export declare function removable(g: Guard, op: string, path: string): Promise<void>;
+export declare function renamable(g: Guard, from: string, to: string): Promise<void>;
+export declare function linkable(g: Guard, from: string, to: string, follow: boolean): Promise<void>;
+export declare function chmodMode(g: Guard, path: string, mode: number): Promise<number>;
+export declare function heldChmodMode(g: Guard, path: string, st: FsStat, mode: number): number;
+export declare function heldRetimable(g: Guard, path: string, st: FsStat, now: boolean): void;
+export declare function retimable(g: Guard, op: string, path: string, now?: boolean): Promise<undefined>;
+export declare function fileWritable(g: Guard, op: string, path: string): Promise<void>;
+export declare function realIds(cred: Readonly<Cred>): Cred;
+export declare function listable(g: Guard, op: string, path: string): Promise<void>;
+export declare function searchable(g: Guard, op: string, path: string, follow: boolean): Promise<void>;
+export declare function readable(g: Guard, op: string, path: string): Promise<void>;
+export declare function writable(g: Guard, op: string, path: string): Promise<void>;
+export declare function creatable(g: Guard, op: string, path: string): Promise<void>;
+export declare function openable(g: Guard, op: string, path: string, want: number, create: boolean): Promise<void>;

package/dist/types/fs/dev-removal.d.ts

@@ -0,0 +1,9 @@
+export declare const SHM = "/dev/shm";
+export declare function inShm(path: string): boolean;
+export declare function inDevTree(path: string): boolean;
+export declare function devRemoval(path: string, cred: Readonly<{
+    euid: number;
+}> | undefined): 'EACCES' | 'EPERM' | 'EBUSY' | undefined;
+export declare function devCreation(path: string, cred: Readonly<{
+    euid: number;
+}> | undefined): 'EACCES' | 'EPERM' | 'EROFS' | undefined;

package/dist/types/fs/fresh-modules.d.ts

@@ -0,0 +1,9 @@
+import { type KernelFs } from './types.js';
+export declare class FreshModules {
+    private readonly fresh;
+    add(path: string, umask: number, pid: number): void;
+    forget(pid: number): void;
+    private drop;
+    private moved;
+    wrap(fs: KernelFs): KernelFs;
+}

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

@@ -0,0 +1,53 @@
+import type { DenialHook } from './dac.js';
+import { type KernelFs } from './types.js';
+export type IntegrityLookup = (path: string) => string | undefined | Promise<string | undefined>;
+export interface IntegrityOptions {
+    readonly lookup: IntegrityLookup;
+    readonly unknown?: 'allow' | 'deny';
+    readonly sources?: readonly string[];
+}
+export declare const SOURCE_SUFFIXES: readonly string[];
+export interface IntegrityCaller {
+    pid: number;
+    uid: number;
+    tag?: string | undefined;
+}
+export declare const KERNEL_CALLER: IntegrityCaller;
+export declare function integrityOptions(options: IntegrityOptions | undefined): void;
+export declare function integritySources(options: {
+    sources?: unknown;
+} | undefined): readonly string[];
+export declare function integrityUnknown(options: {
+    unknown?: string;
+} | undefined): 'allow' | 'deny';
+export declare function sha256(bytes: Uint8Array): Promise<string>;
+export declare class Integrity {
+    private readonly prefixes;
+    private readonly root;
+    private readonly lookup;
+    private readonly unknown;
+    private readonly report;
+    private readonly unverified;
+    private readonly unread;
+    private readonly sources;
+    private readonly passed;
+    private generation;
+    constructor(prefixes: readonly string[], root: KernelFs, options: IntegrityOptions, report: DenialHook);
+    private real;
+    key(path: string, asked?: string): Promise<string | undefined>;
+    read(path: string, caller: IntegrityCaller, plain: () => Promise<Uint8Array>, asked?: string): Promise<Uint8Array>;
+    readKeyed(path: string, caller: IntegrityCaller, plain: () => Promise<Uint8Array>, asked?: string): Promise<{
+        bytes: Uint8Array;
+        key?: string;
+    }>;
+    get readsChecked(): boolean;
+    readSource(path: string, caller: IntegrityCaller, plain: () => Promise<Uint8Array>): Promise<Uint8Array>;
+    openSource(path: string, caller: IntegrityCaller, real?: string): Promise<void>;
+    private checked;
+    private pass;
+    private source;
+    private verify;
+    forget(path?: string): void;
+    private expected;
+    private say;
+}

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

@@ -0,0 +1,86 @@
+export interface MetaEntry {
+    path: string;
+    mode?: number;
+    atimeMs?: number;
+    mtimeMs?: number;
+    mtimeFor?: number;
+    timesAt?: number;
+    timesBy?: string;
+    ctimeMs?: number;
+    ino?: number;
+    link?: string;
+    socket?: true;
+    dir?: string;
+    uid?: number;
+    gid?: number;
+    heir?: [number, number];
+    writes?: number;
+    epoch?: number;
+}
+export type MetaChange = (entry: MetaEntry | undefined) => MetaEntry | undefined;
+export interface MetaStore {
+    get(paths: readonly string[]): Promise<Array<MetaEntry | undefined>>;
+    fresh?(paths: readonly string[]): Promise<Array<MetaEntry | undefined>>;
+    update(path: string, change: MetaChange): Promise<void>;
+    move(from: string, to: string, root: (entry: MetaEntry | undefined) => MetaEntry): Promise<void>;
+    remove(paths: readonly string[]): Promise<void>;
+    links(dir: string): Promise<MetaEntry[]>;
+    under(path: string): Promise<MetaEntry[]>;
+    all(): Promise<MetaEntry[]>;
+    absent?(path: string): boolean;
+    removeFile?(path: string): Promise<void>;
+}
+export declare const META_DB = "slicc-kernel";
+export declare const META_VERSION = 1;
+export declare const META_STORE = "entries";
+export declare class MemoryMeta implements MetaStore {
+    private readonly entries;
+    get(paths: readonly string[]): Promise<Array<MetaEntry | undefined>>;
+    fresh(paths: readonly string[]): Promise<Array<MetaEntry | undefined>>;
+    update(path: string, change: MetaChange): Promise<void>;
+    private set;
+    move(from: string, to: string, root: (entry: MetaEntry | undefined) => MetaEntry): Promise<void>;
+    remove(paths: readonly string[]): Promise<void>;
+    absent(path: string): boolean;
+    links(dir: string): Promise<MetaEntry[]>;
+    under(path: string): Promise<MetaEntry[]>;
+    all(): Promise<MetaEntry[]>;
+}
+interface Invalidation {
+    paths?: readonly string[];
+    trees?: readonly string[];
+}
+export declare class IndexedDbMeta implements MetaStore {
+    private readonly db;
+    private readonly cache;
+    private readonly channel;
+    private generation;
+    private readonly listeners;
+    listen(listener: (change: Invalidation) => void): void;
+    constructor(db: IDBDatabase);
+    private drop;
+    private changed;
+    private transaction;
+    get(paths: readonly string[]): Promise<Array<MetaEntry | undefined>>;
+    fresh(paths: readonly string[]): Promise<Array<MetaEntry | undefined>>;
+    update(path: string, change: MetaChange): Promise<void>;
+    updateMany(changes: ReadonlyArray<{
+        path: string;
+        change: (entry: MetaEntry | undefined) => MetaEntry;
+    }>): Promise<void>;
+    close(): void;
+    move(from: string, to: string, root: (entry: MetaEntry | undefined) => MetaEntry): Promise<void>;
+    absent(path: string): boolean;
+    private removing;
+    private removeTimer;
+    remove(paths: readonly string[]): Promise<void>;
+    removeFile(path: string): Promise<void>;
+    private removeNow;
+    private settleRemoves;
+    private flushRemoves;
+    links(dir: string): Promise<MetaEntry[]>;
+    under(path: string): Promise<MetaEntry[]>;
+    all(): Promise<MetaEntry[]>;
+}
+export declare function openMeta(name: string, factory: IDBFactory): Promise<IndexedDbMeta>;
+export {};

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

@@ -0,0 +1,141 @@
+import { type MetaStore } from './meta.js';
+import { type LockManagerLike, type RemoteListener } from './remote.js';
+import { type FsStat, type KernelFs, type NewOwner, type OwnerChange, type Perm } 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 {
+    write(at: number, bytes: Uint8Array): Promise<void>;
+    truncate(size: number): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function syncAccessHandles(scope?: object): boolean;
+export declare const FILE_TIMES_MS = 100;
+export declare class OpfsFs implements KernelFs {
+    private readonly root;
+    private readonly meta;
+    private readonly dirs;
+    private readonly checked;
+    private readonly channel;
+    private readonly remote;
+    private readonly ranged;
+    private owners;
+    private rejectLinks;
+    private readonly mounts;
+    private readonly locks;
+    private readonly lockPrefix;
+    constructor(root: FileSystemDirectoryHandle, meta?: MetaStore, channel?: string, options?: {
+        ranged?: boolean;
+        locks?: LockManagerLike | null;
+    });
+    private changed;
+    remoteChanges(listener: RemoteListener): () => void;
+    announceWatch(paths: readonly string[]): Promise<void>;
+    private committed;
+    private counted;
+    private stamp;
+    private epoch;
+    private entering;
+    private counting;
+    private recounting;
+    resolvePath(base: string, path: string): string;
+    trackOwners(): void;
+    crossings(mounted: (path: string) => boolean): void;
+    private crossing;
+    hasOwner(path: string): Promise<boolean>;
+    ancestry(path: string): Promise<Perm[]>;
+    private handedTo;
+    private ownerAt;
+    private owned;
+    private newFields;
+    private stampNew;
+    private guarded;
+    protect(prefixes: readonly string[], versions?: boolean): void;
+    unguarded(): KernelFs;
+    noLinks(): KernelFs;
+    private refuse;
+    private locked;
+    chown(path: string, change: OwnerChange): Promise<void>;
+    private movedOwner;
+    private walk;
+    private dir;
+    private current;
+    private forget;
+    private inDir;
+    private child;
+    private parent;
+    private handle;
+    private real;
+    private linkAlong;
+    private locate;
+    private physical;
+    private mode;
+    private readonly id;
+    private readonly dirTimes;
+    private readonly dirDirty;
+    private readonly fileTimes;
+    private written;
+    private scheduleFileTimes;
+    private flushFileTimes;
+    private timesOf;
+    private explicitWins;
+    private movePending;
+    private readonly flushing;
+    private touch;
+    private flushDirTimes;
+    private statOf;
+    private linkStat;
+    private describe;
+    private described;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    exists(path: string): Promise<boolean>;
+    private retrying;
+    private existing;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    readVersioned(path: string, cached?: boolean): Promise<{
+        bytes: Uint8Array;
+        version: string;
+    }>;
+    version(path: string, cached?: boolean): Promise<string>;
+    pread(path: string, offset: number, length: number): Promise<Uint8Array>;
+    pwrite(path: string, offset: number, bytes: Uint8Array): Promise<void>;
+    truncate(path: string, size: number): Promise<void>;
+    writeSession(path: string, truncate: boolean): Promise<WriteSession>;
+    readFile(path: string): Promise<string>;
+    private writeTarget;
+    private locateWrite;
+    private fileFor;
+    writeFile(path: string, content: Uint8Array | string, owner?: NewOwner): Promise<void>;
+    private listing;
+    readdir(path: string): Promise<string[]>;
+    readdirStat(path: string): Promise<Array<[string, FsStat | null]>>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        owner?: NewOwner;
+    }): Promise<void>;
+    private mkdirExcl;
+    createExclusive(path: string, owner?: NewOwner): Promise<void>;
+    private handleExists;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+        file?: boolean;
+    }): Promise<void>;
+    links(): boolean;
+    link(from: string, to: string, follow?: boolean): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    private moveTo;
+    private modified;
+    private explicitTimes;
+    private restamp;
+    private place;
+    private copy;
+    symlink(target: string, path: string, owner?: NewOwner): Promise<void>;
+    realpath(path: string, follow: boolean): Promise<string>;
+    readlink(path: string): Promise<string>;
+    chmod(path: string, mode: number): Promise<void>;
+    utimes(path: string, atime: Date, mtime: Date): Promise<void>;
+    lutimes(path: string, atime: Date, mtime: Date): Promise<void>;
+    private setTimes;
+    reconcile(): Promise<number>;
+}

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

@@ -0,0 +1,17 @@
+import type { Cred } from '../kernel/cred.js';
+import type { MetaEntry } from './meta.js';
+import { type KernelFs, type NewOwner, type Owner } from './types.js';
+export declare const ROOT_OWNER: Readonly<Owner>;
+export declare function ownOf(entry: MetaEntry | undefined): Owner | undefined;
+export declare function inherit(entries: ReadonlyArray<MetaEntry | undefined>): Owner;
+export declare function chain(path: string): string[];
+export declare function sameOwner(a: Owner, b: Owner): boolean;
+export declare function ownerOf(cred: Readonly<Cred>, mode?: number): NewOwner;
+export declare function inGroup(cred: Readonly<Cred>, gid: number): boolean;
+export declare function mayChown(cred: Readonly<Cred>, current: Owner, uid: number | undefined, gid: number | undefined): boolean;
+export declare function clearedSetId(mode: number): number;
+export declare function chownAs(fs: KernelFs, cred: Readonly<Cred>, path: string, change: {
+    uid?: number;
+    gid?: number;
+    follow: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,41 @@
+export declare const PAGE: number;
+export declare const READAHEAD: number;
+export declare const CLEAN_LIMIT: number;
+export declare const WRITEBACK: number;
+export declare const RUN: number;
+export interface Run {
+    offset: number;
+    bytes: Uint8Array;
+}
+export interface FlushPlan {
+    shrink?: number;
+    runs: Run[];
+    extend?: number;
+}
+export declare class Pages {
+    length: number;
+    private stored;
+    private shrink;
+    private readonly pages;
+    private readonly dirty;
+    private readonly free;
+    private pinned;
+    constructor(size: number);
+    get dirtyBytes(): number;
+    get changed(): boolean;
+    missing(at: number, length: number): Array<[number, number]>;
+    partial(at: number, length: number): Array<[number, number]>;
+    fill(start: number, bytes: Uint8Array): void;
+    read(at: number, length: number): Uint8Array;
+    readInto(at: number, out: Uint8Array): number;
+    write(at: number, bytes: Uint8Array): void;
+    truncate(size: number): void;
+    plan(): FlushPlan;
+    flushed(): void;
+    pin(): void;
+    reset(size: number): void;
+    refresh(size: number): void;
+    private evict;
+    private take;
+    private drop;
+}

package/dist/types/fs/path-map.d.ts

@@ -0,0 +1,16 @@
+export declare class PathMap<V> {
+    private readonly values;
+    private readonly children;
+    get size(): number;
+    has(path: string): boolean;
+    get(path: string): V | undefined;
+    keys(): IterableIterator<string>;
+    set(path: string, value: V): this;
+    delete(path: string): boolean;
+    subtree(root: string): string[];
+    entries(): IterableIterator<[string, V]>;
+    deleteTree(root: string): void;
+    clear(): void;
+    private link;
+    private prune;
+}

package/dist/types/fs/physical-path.d.ts

@@ -0,0 +1,14 @@
+export interface LinkReader {
+    lstat(path: string): {
+        isSymbolicLink?: boolean;
+    };
+    readlink(path: string): string;
+}
+export declare function physicalPath(fs: LinkReader, path: string): string;
+export interface AsyncLinkReader {
+    lstat(path: string): Promise<{
+        isSymbolicLink?: boolean;
+    }>;
+    readlink(path: string): Promise<string>;
+}
+export declare function physicalPathAsync(fs: AsyncLinkReader, path: string): Promise<string>;

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

@@ -0,0 +1,27 @@
+import { type IntegrityOptions } from './integrity.js';
+import { type KernelFs } from './types.js';
+export interface Protection {
+    readonly paths: readonly string[];
+    readonly writers?: readonly string[];
+    readonly integrity?: IntegrityOptions;
+}
+export interface ProtectInit {
+    paths: string[];
+    writers?: string[];
+    integrity?: {
+        unknown: 'allow' | 'deny';
+        sources?: readonly string[];
+    };
+}
+export declare function protectInit(protection: ProtectInit | Protection): ProtectInit;
+export declare function writerTags(protection: Protection | undefined): ReadonlySet<string>;
+export declare function protectedPrefixes(paths: readonly string[]): string[];
+export declare function isProtected(prefixes: readonly string[], path: string): boolean;
+export declare function holdsProtected(prefixes: readonly string[], path: string): boolean;
+export declare function namesOf(fs: KernelFs, path: string): Promise<string[]>;
+export declare class ProtectedFs {
+    private readonly prefixes;
+    constructor(prefixes: readonly string[]);
+    check(fs: KernelFs, path: string, follow: boolean, whole?: boolean): Promise<void>;
+    view(fs: KernelFs): KernelFs;
+}

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

@@ -0,0 +1,73 @@
+import type { ChangeView } from './changes.js';
+type WatchStat = {
+    size: number;
+    version?: string | undefined;
+    ino?: number | undefined;
+    mtimeMs?: number | undefined;
+    nlink?: number | undefined;
+};
+export interface RangedWatch {
+    view: ChangeView;
+    ino?: number | undefined;
+    seen?: number | undefined;
+    stat(path: string): WatchStat;
+    real?: () => string | undefined;
+    linked?: boolean;
+    resolved?: string | null;
+    sig?: string;
+}
+export declare const signatureOf: (st: WatchStat) => string;
+export declare function linkedWatch<T extends RangedWatch>(watch: T, st: WatchStat): T;
+export declare function watchedChange(watch: RangedWatch, seen: number, path: string): {
+    now: number;
+    changed: boolean;
+};
+export interface RangedIo {
+    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;
+}
+export interface AsyncRangedIo {
+    pread(path: string, offset: number, length: number, version?: string): Promise<Uint8Array>;
+    pwrite(path: string, offset: number, bytes: Uint8Array, transfer?: boolean): Promise<void>;
+    truncate(path: string, size: number): Promise<void>;
+}
+export declare class RangedFile {
+    private readonly pages;
+    private readonly io;
+    private pinned;
+    private version;
+    private readonly watch;
+    private seen;
+    path: string;
+    constructor(io: RangedIo, path: string, size: number, version?: string, watch?: RangedWatch);
+    private fresh;
+    get changed(): boolean;
+    get pinnedVersion(): string | undefined;
+    forget(): void;
+    size(): number;
+    private fetch;
+    read(at: number, length: number): Uint8Array;
+    readInto(at: number, out: Uint8Array): number;
+    write(at: number, bytes: Uint8Array): void;
+    truncate(size: number): void;
+    flush(): void;
+    pin(): void;
+    reset(size: number): void;
+}
+export declare class AsyncRangedFile {
+    private readonly pages;
+    private readonly io;
+    private pinned;
+    private version;
+    path: string;
+    constructor(io: AsyncRangedIo, path: string, size: number, version?: string);
+    size(): number;
+    private fetch;
+    read(at: number, length: number): Promise<Uint8Array>;
+    write(at: number, bytes: Uint8Array): Promise<void>;
+    truncate(size: number): void;
+    flush(): Promise<void>;
+    pin(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,45 @@
+export interface RemoteChange {
+    paths: readonly string[];
+    trees: readonly string[];
+}
+export type RemoteListener = (change: RemoteChange) => void;
+export declare const ANNOUNCE_WAIT_MS = 500;
+export declare const PRUNE_EVERY_MS = 30000;
+export interface LockManagerLike {
+    request(name: string, callback: () => Promise<void>): Promise<unknown>;
+    query(): Promise<{
+        held?: Array<{
+            name?: string;
+        }>;
+    }>;
+}
+export declare function lockManager(): LockManagerLike | undefined;
+export declare class RemoteWatch {
+    private readonly channel;
+    private readonly name;
+    private readonly tab;
+    private readonly peers;
+    private readonly others;
+    private readonly union;
+    private readonly listeners;
+    private readonly waiting;
+    private readonly locks;
+    private mine;
+    private seq;
+    private pruned;
+    constructor(name: string, options?: {
+        locks?: LockManagerLike | null;
+    });
+    private lockOf;
+    private receive;
+    private greeted;
+    private announced;
+    private acked;
+    private rebuild;
+    prune(): Promise<void>;
+    watched(): boolean;
+    wrote(path: string): void;
+    announce(paths: readonly string[]): Promise<void>;
+    emit(change: RemoteChange): void;
+    listen(listener: RemoteListener): () => void;
+}