@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

package/dist/types/kernel/vfs-file.d.ts

@@ -0,0 +1,149 @@
+import { type AsyncRangedIo } from '../fs/ranged.js';
+import { type KernelFs, type NewOwner, type OwnerChange } from '../fs/types.js';
+import type { KeptFile, UnlinkHolder } from '../fs/unlinked.js';
+import { OpenFile } from './fd-table.js';
+export interface VfsFileFs extends Partial<AsyncRangedIo> {
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: Uint8Array, owner?: NewOwner): Promise<void>;
+    mayChange?(path: string, follow: boolean, whole?: boolean): Promise<void>;
+    stat?(path: string): Promise<{
+        readonly?: boolean;
+        maxFile?: number;
+        size?: number;
+        ranged?: boolean;
+        version?: string;
+        ino?: number;
+        dev?: number;
+        nlink?: number;
+    }>;
+    readlink?(path: string): Promise<string>;
+    lstat?(path: string): Promise<unknown>;
+    realpath?(path: string, follow: boolean): Promise<string>;
+    chown?(path: string, change: OwnerChange): Promise<void>;
+    chmod?(path: string, mode: number): Promise<void>;
+    links?(path: string): boolean;
+    exclusive?<T>(path: string, run: () => Promise<T>): Promise<T>;
+}
+export interface VfsFileOptions {
+    path: string;
+    flags: number;
+    position: number;
+    contents?: Uint8Array;
+    orphan?: boolean;
+    dirty?: boolean;
+    pin?: VersionPin;
+    truncate?: boolean;
+    create?: boolean;
+    id?: string;
+}
+export interface VersionPin {
+    version: string;
+    size: number;
+}
+export declare const WRITEBACK_MS = 250;
+export declare class VfsNode {
+    private data;
+    private ranged;
+    private readonly pin;
+    private length;
+    private dirty;
+    private queue;
+    private writeBack;
+    private writeBackCost;
+    opens: number;
+    writers: number;
+    private missing;
+    private revoked;
+    private readonly fs;
+    path: string;
+    orphaned: boolean;
+    id: string | undefined;
+    onDirty: (() => void) | undefined;
+    onDirtyState: ((on: boolean) => void) | undefined;
+    private counted;
+    recount(): void;
+    constructor(fs: VfsFileFs, path: string, contents?: Uint8Array, orphaned?: boolean, dirty?: boolean, pin?: VersionPin);
+    serial<T>(op: () => Promise<T>): Promise<T>;
+    revoke(): void;
+    private prepare;
+    keep(): Promise<void>;
+    load(): Promise<Uint8Array>;
+    holds(): boolean;
+    replace(contents: Uint8Array): void;
+    materialize(): Promise<void>;
+    size(): Promise<number>;
+    pread(max: number, at: number): Promise<Uint8Array>;
+    private cap;
+    limit(): Promise<number | undefined>;
+    private seen;
+    private note;
+    known(): number | undefined;
+    private fits;
+    renamedTo(path: string): void;
+    pwrite(bytes: Uint8Array, at: number): Promise<number>;
+    truncate(size: number): Promise<void>;
+    private markDirty;
+    private ensure;
+    flush(): Promise<void>;
+}
+export declare class VfsNodes implements UnlinkHolder {
+    private readonly byPath;
+    private readonly kept;
+    private readonly byId;
+    keepsOnDisk: boolean;
+    changed: ((path: string) => void) | undefined;
+    dirtied: ((delta: number) => void) | undefined;
+    private readonly fs;
+    readonly entries: Map<string, Promise<unknown>>;
+    private readonly onClosed;
+    constructor(fs: VfsFileFs, onClosed?: (path: string) => void, entries?: Map<string, Promise<unknown>>);
+    onEntry<T>(path: string, op: () => Promise<T>): Promise<T>;
+    entryKey(path: string): Promise<string>;
+    targetKey(path: string): Promise<string>;
+    private real;
+    createExclusive(path: string, owner?: NewOwner): Promise<void>;
+    private identity;
+    identify(path: string): Promise<string | undefined>;
+    flushLinked(path: string): Promise<void>;
+    linked(from: string, to: string): Promise<void>;
+    private know;
+    private namesOf;
+    private forget;
+    private orphan;
+    private dropName;
+    holdsAny(): boolean;
+    private epoch;
+    private readonly plain;
+    reshaped(): void;
+    plainAt(path: string): boolean;
+    get shape(): number;
+    notePlain(path: string, shape: number): void;
+    holdsName(name: string): boolean;
+    holdsLinked(): boolean;
+    holdingId(id: string): VfsNode | undefined;
+    holding(path: string): VfsNode | undefined;
+    private named;
+    private create;
+    open(path: string, pin?: VersionPin, writable?: boolean, id?: string): VfsNode;
+    adopt(path: string, contents: Uint8Array, dirty: boolean, writable?: boolean, id?: string): VfsNode;
+    holds(prefix: string): boolean;
+    writes(prefix: string): boolean;
+    closed(node: VfsNode, writable?: boolean): void;
+    held(): Iterable<string>;
+    owns(): boolean;
+    isKept(): boolean;
+    keep(path: string, file: KeptFile): void;
+    unkeep(path: string, file: KeptFile): void;
+    flush(path: string): Promise<void>;
+    unlinking(path: string): Promise<void>;
+    revoke(prefix: string): void;
+    unlinked(path: string): void;
+    renamed(from: string, to: string): void;
+}
+export declare function present(fs: VfsFileFs, path: string, follow?: boolean): Promise<boolean>;
+export declare function refuseReadonly(fs: VfsFileFs, path: string, flags: number, opts?: {
+    create?: boolean;
+    truncate?: boolean;
+}): Promise<void>;
+export declare function keepingOpen(fs: KernelFs, nodes: VfsNodes, changed?: (path: string) => void): KernelFs;
+export declare function vfsFile(fs: VfsFileFs, opts: VfsFileOptions, nodes?: VfsNodes): OpenFile;

package/dist/types/launcher.d.ts

@@ -0,0 +1,359 @@
+import { CdpHosts } from './cdp/hosts.js';
+import type { CdpHook } from './cdp/types.js';
+import { type Abi, type Command } from './commands.js';
+import { FacadeHosts } from './facade/hosts.js';
+import type { FacadeSpecs } from './facade/types.js';
+import { type Attestation } from './fs/attest.js';
+import { Dac, type DenialHook } from './fs/dac.js';
+import { type Protection } from './fs/protect.js';
+import type { KernelFs, UsersMode } from './fs/types.js';
+import { type UnlinkOwner } from './fs/unlinked.js';
+import { FsWatchers } from './fs/watch.js';
+import { type ClipboardHook } from './kernel/clipboard.js';
+import type { CpuTimes } from './kernel/cpu-clock.js';
+import { type Cred } from './kernel/cred.js';
+import { type WasmWorkerLike } from './kernel/host.js';
+import type { CaStore } from './kernel/net/realm-ca.js';
+import { Resolver } from './kernel/net/resolver.js';
+import { Routes, type RouteTable } from './kernel/net/routes.js';
+import type { RealmTransport } from './kernel/net/transport.js';
+import type { NetworkUplink } from './kernel/net/uplink.js';
+import type { ProcessInfo } from './kernel/proc-info.js';
+import { type SealedCaller, type SealedHook } from './kernel/sealed.js';
+import { LoopbackNet } from './kernel/socket.js';
+import { type MediumHandle } from './mount/fsa.js';
+import { type FstabResult } from './mount/fstab.js';
+import { type FetchLike, type HostfsGrantHook, type HostfsTiming } from './mount/hostfs.js';
+import { type MediaStore } from './mount/media.js';
+import { type MountEntry, type MountSpec, MountTable } from './mount/mount-fs.js';
+import { type ProcessMountPolicy } from './mount/syscall.js';
+import { type ApproveHook } from './sudo.js';
+import { type Account, UserDb } from './users.js';
+export interface LauncherOptions {
+    unlinkOwner?: UnlinkOwner;
+    fs: KernelFs;
+    createWorker: () => WasmWorkerLike;
+    modules?: string;
+    commands?: {
+        append?: readonly string[];
+    };
+    env?: Record<string, string>;
+    transport?: RealmTransport;
+    caStore?: CaStore;
+    createDriverWorker?: () => WasmWorkerLike;
+    media?: MediaStore;
+    onMountPending?: (pending: PendingMedium) => void;
+    hostfs?: HostfsGrantHook;
+    hostfsFetch?: FetchLike;
+    hostfsTiming?: HostfsTiming;
+    processMounts?: ProcessMountPolicy;
+    fstabRetries?: readonly number[];
+    cdp?: CdpHook;
+    facades?: FacadeSpecs;
+    uplink?: NetworkUplink;
+    hostname?: string;
+    users?: UsersMode;
+    onDenial?: DenialHook;
+    sealed?: SealedHook;
+    clipboard?: ClipboardHook;
+    approve?: ApproveHook;
+    sudoTimeoutMs?: number;
+    protect?: Protection;
+}
+export interface PendingMedium {
+    target: string;
+    source: string;
+    handle?: MediumHandle;
+}
+export interface RunOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    stdin?: Uint8Array;
+    onStdout?: (bytes: Uint8Array) => void;
+    onStderr?: (bytes: Uint8Array) => void;
+    onStarted?: (pid: number) => void;
+    collect?: boolean;
+    pgid?: number;
+    user?: string | number | Account;
+    tag?: string;
+}
+export interface TerminalOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    user?: string | number | Account;
+    tag?: string;
+    onData: (bytes: Uint8Array) => void;
+}
+export interface TerminalSession {
+    pid: number;
+    exited: Promise<number>;
+    termsig(): number | undefined;
+    write(bytes: Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    signal(sig: number): void;
+    close(): void;
+}
+export interface RunResult {
+    status: number;
+    signal?: number;
+    stdout: Uint8Array;
+    stderr: Uint8Array;
+}
+interface Target {
+    abi: Abi;
+    glue: string;
+    wasm: string;
+    argv0: string;
+    fixed?: true;
+    prefix?: string[];
+    env?: Record<string, string>;
+    unset?: string[];
+    imports?: string;
+    preopenRoot?: boolean;
+    asked?: string;
+}
+export declare function tagOption(tag: unknown): void;
+export declare function expandDefaults(defaults: Readonly<Record<string, string>> | undefined, env: Readonly<Record<string, string>>): Record<string, string>;
+export declare class Launcher {
+    readonly fs: KernelFs;
+    readonly processFs: KernelFs;
+    private readonly noLinksFs;
+    private readonly mounted;
+    private protection;
+    private readonly prefixes;
+    private readonly writerTags;
+    private readonly unguardedRoot;
+    private writers;
+    private readonly unlinkOwnerOption;
+    private readonly base;
+    private readonly createWorker;
+    private readonly modulesDir;
+    private readonly appended;
+    private readonly reportedRoots;
+    private readonly env;
+    private readonly catalogs;
+    private readonly ownCatalogs;
+    private readonly binfmts;
+    private scopes;
+    private unwatchScopes;
+    private readonly warned;
+    private readonly compiled;
+    private readonly texts;
+    private revocations;
+    private integrity;
+    private scannedFs;
+    private get scanned();
+    private readonly processes;
+    private readonly zombies;
+    private readonly orphans;
+    private readonly described;
+    private readonly creds;
+    private readonly tags;
+    private readonly links;
+    private readonly freshModules;
+    private readonly granted;
+    readonly users: UserDb;
+    private readonly sudoer;
+    private readonly jobs;
+    private readonly locks;
+    private readonly sems;
+    private readonly settling;
+    private readonly ptys;
+    readonly net: LoopbackNet;
+    readonly cdp: CdpHosts;
+    readonly facades: FacadeHosts;
+    private readonly ca;
+    readonly transport: RealmTransport;
+    readonly uplink: NetworkUplink | undefined;
+    readonly routes: Routes;
+    readonly resolver: Resolver;
+    readonly hostname: string;
+    readonly watchers: FsWatchers;
+    private readonly changes;
+    private readonly pnpmHome;
+    private readonly pnpmChain;
+    private pnpmMade;
+    private pnpmEpoch;
+    readonly mounts: MountTable;
+    private readonly createDriverWorker;
+    private readonly media;
+    private readonly onMountPending;
+    private readonly removable;
+    private readonly hostfs;
+    private readonly fstabRetries;
+    private readonly inserted;
+    private readonly openFiles;
+    private readonly deciding;
+    readonly identities: {
+        asked: number;
+        timedOut: number;
+    };
+    private readonly nodes;
+    private readonly unlinked;
+    private readonly held;
+    private readonly processMounts;
+    private readonly booting;
+    fstab: Promise<FstabResult[]>;
+    readonly usersMode: UsersMode;
+    readonly dac: Dac | undefined;
+    private readonly sealed;
+    private readonly scrubs;
+    private readonly clipboard;
+    private readonly rootFs;
+    private fileWatches;
+    private nextPid;
+    readonly boot: number;
+    private terminals;
+    constructor(options: LauncherOptions);
+    get owners(): boolean;
+    setRoutes(table: RouteTable): void;
+    private readonly traitsListeners;
+    private announcedTraits;
+    onTraits(listener: () => void): () => void;
+    updateTransportTraits(): boolean;
+    commands(scope?: string): Promise<Map<string, Command>>;
+    private ownCommands;
+    private interpreters;
+    private tiers;
+    private roots;
+    private rootOnlyPath;
+    private trustedAppended;
+    private resetCatalogs;
+    private userScopes;
+    private userCommandDir;
+    private scopeOf;
+    private commandAt;
+    resolve(file: string, argv0: string, cwd: string, scope?: string): Promise<Target | undefined>;
+    private glueOwner;
+    private wasmOwner;
+    private head;
+    private scriptCommand;
+    private interpreted;
+    private plan;
+    private mayExec;
+    private checkedPlan;
+    private execGuard;
+    private execFile;
+    private ticketFile;
+    private takeTicket;
+    private redeemed;
+    private redeem;
+    private interpreterChain;
+    private commandFile;
+    private trustedFiles;
+    private grantedCwd;
+    private binfmtManifests;
+    private backing;
+    private backingOf;
+    private unrunnable;
+    private directory;
+    verifiedFs(fs: KernelFs): KernelFs;
+    private cacheKey;
+    private verified;
+    private keyed;
+    private cached;
+    private module;
+    private checkedSources;
+    private text;
+    private names;
+    private program;
+    private launch;
+    groupSession(pgid: number): number | undefined;
+    private loopbackFor;
+    private sourceCheck;
+    private treeScrubs;
+    private marks;
+    private start;
+    private shownIds;
+    private forget;
+    private reaped;
+    private load;
+    private sampler;
+    private readonly reapedTimes;
+    private readonly idleAt;
+    cpuTotal(now?: number): CpuTimes & {
+        idle: number;
+    };
+    loadAverage(): readonly [number, number, number];
+    private sampledAt;
+    sampleLoad(now?: number): void;
+    private idleSince;
+    private sampling;
+    private readonly spent;
+    private readonly imageTimes;
+    private readonly childTimes;
+    private readonly stopped;
+    private stateOf;
+    private childrenOf;
+    private timesAt;
+    private timesOf;
+    list(viewer?: Readonly<Cred>): ProcessInfo[];
+    private threadsOf;
+    private sudo;
+    private spawner;
+    private childGroup;
+    private undecided;
+    connectorStamp(pid: number): Promise<SealedCaller>;
+    private identityOf;
+    private running;
+    private decide;
+    private forker;
+    private keySignal;
+    private resolvePrefixes;
+    private guardMount;
+    private umaskOf;
+    private imageOf;
+    credOf(pid: number): Cred;
+    tagOf(pid: number): string | undefined;
+    private released;
+    private signalMasksOf;
+    private controlsJobs;
+    private blockedBy;
+    private ignoredBy;
+    kill(pid: number, sig: number, sender?: Readonly<Cred>, from?: number): boolean;
+    private killAll;
+    private driver;
+    private fsaDriver;
+    revokeIntegrity(path?: string): Promise<void>;
+    attest(path: string): Promise<Attestation>;
+    watchFiles(paths: readonly string[], notify: (path: string) => void): Promise<() => void>;
+    mount(spec: MountSpec): Promise<MountEntry>;
+    private mountShm;
+    private ownTmp;
+    private inUse;
+    private stampLayout;
+    private realLayoutPath;
+    private pnpmReady;
+    private pnpmStale;
+    private mountedBy;
+    private mountRoot;
+    insert(target: string, handle: MediumHandle, source?: string): Promise<void>;
+    umount(target: string, detach?: boolean): void;
+    unmountAll(): void;
+    private permit;
+    private processMount;
+    mountAs(cred: Cred, spec: MountSpec): Promise<MountEntry>;
+    umountAs(cred: Cred, target: string): Promise<void>;
+    private mountsOwn;
+    private processUmount;
+    prepare(): Promise<void>;
+    private mountFstab;
+    private environment;
+    private account;
+    private terminalAccount;
+    private identity;
+    fsFor(tag: string | undefined): KernelFs;
+    isWriter(tag: string | undefined): boolean;
+    private stackFor;
+    private writerStack;
+    private noLinksOf;
+    private rooted;
+    private commandFs;
+    private processChain;
+    private starting;
+    openTerminal(argv: string[], options: TerminalOptions): Promise<TerminalSession>;
+    run(argv: string[], options?: RunOptions): Promise<RunResult>;
+}
+export type { ProcessInfo, ProcessListing } from './kernel/proc-info.js';

package/dist/types/local-proxy-transport.d.ts

@@ -0,0 +1,39 @@
+import type { RealmTransport } from './kernel/net/transport.js';
+export interface LocalProxyOptions {
+    url: string;
+    key: string;
+    fetch?: typeof globalThis.fetch;
+}
+export interface LocalProxyCheckOptions extends LocalProxyOptions {
+    permissions?: Pick<Permissions, 'query'>;
+}
+export interface LocalProxyTransportOptions extends LocalProxyOptions {
+    maxRequestBody?: number;
+    bodyIdleMs?: number;
+}
+export interface LocalProxyProbe {
+    rawFetch: number;
+    requestBodyStreaming: boolean;
+    maxRequestBodyBytes: number;
+    kernelTunnel?: number;
+    kernelPort?: number;
+    cdp?: number;
+}
+export type LocalProxyStatus = {
+    state: 'ready';
+    probe: LocalProxyProbe;
+} | {
+    state: 'blocked';
+} | {
+    state: 'unreachable';
+    permission: 'granted' | 'prompt' | 'unknown';
+} | {
+    state: 'refused';
+    status: number;
+    error: string;
+} | {
+    state: 'incompatible';
+};
+export declare function checkLocalProxy(options: LocalProxyCheckOptions): Promise<LocalProxyStatus>;
+export declare function probeLocalProxy(options: LocalProxyCheckOptions): Promise<LocalProxyProbe | null>;
+export declare function localProxyTransport(options: LocalProxyTransportOptions): RealmTransport;

package/dist/types/meta.d.ts

@@ -0,0 +1,11 @@
+export interface MetadataEntry {
+    path: string;
+    mode?: number;
+    uid?: number;
+    gid?: number;
+}
+export interface WriteMetadataOptions {
+    metadata?: string;
+    indexedDB?: IDBFactory;
+}
+export declare function writeMetadata(root: FileSystemDirectoryHandle, entries: readonly MetadataEntry[], options?: WriteMetadataOptions): Promise<void>;

package/dist/types/mount/chunked.d.ts

@@ -0,0 +1,9 @@
+export declare const CHUNK: number;
+export declare class ChunkedBytes {
+    private chunks;
+    size: number;
+    read(offset: number, length: number): Uint8Array;
+    write(offset: number, bytes: Uint8Array, owned?: boolean): void;
+    truncate(size: number): void;
+    private room;
+}

package/dist/types/mount/connection.d.ts

@@ -0,0 +1,35 @@
+import { type DriverCall, type DriverCapabilities, type MountRequestInfo } from './protocol.js';
+export interface DriverPortLike {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+    start?(): void;
+    close?(): void;
+    ref?(): void;
+    unref?(): void;
+}
+export interface ConnectionOptions {
+    timeoutMs?: number;
+    idle?: boolean;
+    onInvalidate?: (paths: string[] | true) => void;
+    onFail?: (error: Error) => void;
+}
+export declare const DRIVER_TIMEOUT_MS = 30000;
+export declare function errnoError(code: string, message: string): Error & {
+    code: string;
+};
+export declare class DriverConnection {
+    readonly capabilities: DriverCapabilities;
+    failure: Error | undefined;
+    private readonly port;
+    private readonly waiting;
+    private readonly timeoutMs;
+    private nextId;
+    private readonly onFail;
+    private readonly idle;
+    private constructor();
+    private settled;
+    static open(port: DriverPortLike, mount: MountRequestInfo, options?: ConnectionOptions): Promise<DriverConnection>;
+    call(call: DriverCall, transfer?: Transferable[]): Promise<unknown>;
+    fail(error: Error): void;
+    close(): void;
+}

package/dist/types/mount/driver.d.ts

@@ -0,0 +1,50 @@
+import { type DriverAttr, type DriverCapabilities, type DriverEntry, type DriverOwner, type DriverStatfs, type MountRequestInfo } from './protocol.js';
+export type { DriverAttr, DriverCapabilities, DriverEntry, DriverOwner, DriverStatfs, MountRequestInfo, } from './protocol.js';
+export interface OpenFlags {
+    write: boolean;
+    create: boolean;
+    truncate: boolean;
+    exclusive: boolean;
+    ifMatch?: string;
+    owner?: DriverOwner;
+}
+export interface FilesystemHandlers {
+    mount?(info: MountRequestInfo): Promise<DriverCapabilities | undefined> | DriverCapabilities | undefined;
+    getattr(path: string): Promise<DriverAttr>;
+    readdir(path: string): Promise<DriverEntry[]>;
+    open(path: string, flags: OpenFlags): Promise<number>;
+    read(fh: number, offset: number, size: number): Promise<Uint8Array>;
+    write(fh: number, offset: number, bytes: Uint8Array): Promise<void>;
+    release(fh: number): Promise<void>;
+    mkdir(path: string, owner?: DriverOwner): Promise<void>;
+    rmdir(path: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    link?(from: string, to: string): Promise<void>;
+    symlink?(target: string, path: string, owner?: DriverOwner): Promise<void>;
+    readlink?(path: string): Promise<string>;
+    setattr?(path: string, attr: DriverSetAttr): Promise<void>;
+    statfs?(): Promise<DriverStatfs>;
+}
+export interface DriverSetAttr {
+    mode?: number;
+    mtime?: number;
+    atime?: number;
+    size?: number;
+    uid?: number;
+    gid?: number;
+}
+export interface DriverPort {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', handler: (event: MessageEvent) => void): void;
+    start?(): void;
+}
+export interface ServedFilesystem {
+    invalidate(paths: string[] | true): void;
+}
+export declare function fsError(code: string, message?: string): Error & {
+    code: string;
+};
+export declare function serveFilesystem(port: DriverPort, handlers: FilesystemHandlers, capabilities?: DriverCapabilities, options?: {
+    owned?: boolean;
+}): ServedFilesystem;

package/dist/types/mount/fsa.d.ts

@@ -0,0 +1,26 @@
+import { OpfsFs } from '../fs/opfs.js';
+import type { KernelFs } from '../fs/types.js';
+import { type FilesystemHandlers } from './driver.js';
+import type { DriverCapabilities } from './protocol.js';
+export declare const FSA_CAPABILITIES: DriverCapabilities;
+export interface PermissionHandle {
+    queryPermission?(descriptor: {
+        mode: 'read' | 'readwrite';
+    }): Promise<PermissionState>;
+    requestPermission?(descriptor: {
+        mode: 'read' | 'readwrite';
+    }): Promise<PermissionState>;
+}
+export type MediumHandle = FileSystemDirectoryHandle & PermissionHandle;
+type Handlers = Required<Omit<FilesystemHandlers, 'mount' | 'statfs' | 'link'>>;
+export type SessionFs = KernelFs & Pick<OpfsFs, 'writeSession' | 'pread'>;
+export declare function kernelFsHandlers(fs: SessionFs): Handlers;
+export interface Medium {
+    readonly handlers: FilesystemHandlers;
+    present(): boolean;
+    insert(handle: MediumHandle): void;
+    eject(): void;
+}
+export declare function granted(handle: PermissionHandle): Promise<boolean>;
+export declare function removableMedium(onLost: (handle: MediumHandle) => void, open?: (handle: MediumHandle) => SessionFs): Medium;
+export {};