@phreshos/client 0.1.37 → 0.1.39

package/dist/events.d.ts

@@ -1,4 +1,4 @@
-import type { Cleanup, EventOptions, Subscribable } from "@phreshos/core";
+import { subscribableDefinition, type Cleanup, type EventOptions, type Subscribable, type SubscribableDefinition } from "@phreshos/core";
 export declare const defaultTimeout = 10000;
 type Failure = (error: Error) => void;
 type Listener = (message: unknown) => unknown;
@@ -8,9 +8,10 @@ type Register<Message> = (listener: (message: Message) => unknown, impossible?:
 export default class Events<Vocabulary extends object = {}, Fallback = unknown> implements Subscribable<Vocabulary, Fallback> {
     private readonly listen;
     private readonly listenAll;
+    readonly [subscribableDefinition]?: SubscribableDefinition<Vocabulary, Fallback>;
     constructor(listen: (event: string, listener: Listener, impossible?: Failure) => Cleanup, listenAll: (listener: EveryListener, impossible?: Failure) => Cleanup);
     readonly subscribe: Subscribable<Vocabulary, Fallback>["subscribe"];
-    readonly waitFor: Subscribable<Vocabulary, Fallback>["waitFor"];
+    readonly wait: Subscribable<Vocabulary, Fallback>["wait"];
     readonly events: Subscribable<Vocabulary, Fallback>["events"];
 }
 /** Converts one persistent registration into a bounded asynchronous iterator. */

package/dist/events.js

@@ -1,3 +1,4 @@
+import { subscribableDefinition } from "@phreshos/core";
 export const defaultTimeout = 10_000;
 /** SDK-owned waits, queues and callbacks over boundary forwarding state. */
 export default class Events {
@@ -12,7 +13,7 @@ export default class Events {
             return this.listen(eventOrSubscriber, subscriber);
         return this.listenAll((event, message) => eventOrSubscriber({ event, message }));
     });
-    waitFor = ((event, timeout = defaultTimeout) => {
+    wait = ((event, timeout = defaultTimeout) => {
         return new Promise((resolve, reject) => {
             let settled = false;
             let stop = () => undefined;

package/dist/main.d.ts

@@ -1,6 +1,3 @@
 export { system } from "./system.js";
 export { desktop } from "./desktop/desktop.js";
-export { context, type Context, type ContextCapture, type ContextEvents, type ContextMessage, type ContextServer } from "./context.js";
-export { ClientService, ServerService, Service, clientPermissionCatalog, isPermissionName, type ServiceKey, } from "@phreshos/core";
-export { ClientEndpoint, Endpoint, Process, Program, ServerEndpoint, type Window, type ProgramProcess, type ProgramProcessRunEvent, type ProgramProcessRunOptions, type AnswerCapture, type AnswerMessage, type AnswerSubscriber, type AskCapture, type AskMessage, type AskSubscriber, type ClientTraffic, type EndpointTraffic, type ServerTraffic, type TrafficCapture, type TrafficEvents, type TrafficMessage } from "./domain.js";
-export type { Askable, AnswerOutcome, ClientContext, Capture, Captures, CaptureSubscriber, ClientLaunch, ClientDeclaration, Cleanup, DirectoryStat, EndpointDeclaration, EndpointLifecycle, EndpointLifecycleEvents, EntryStat, EventMessage, EventName, EventOptions, EventSubscriber, Exit, FileStat, Launch, ServerLaunch, ShellEvent, ShellOptions, Layer, LogKind, LogRecord, LogSource, Message, OtherStat, Permission, PermissionDefinition, PermissionDefinitions, PermissionInput, PermissionName, PermissionRequest, PermissionValue, PermissionValueDomain, Permissions, ClientPermissionDeclarations, ClientPermissions, ContextPermissions, ProgramPermissions, TimedContextPermissions, Position, Storage, ProgramEvents, ProgramProcessEvents, ProgramProcessExit, ProgramStartup, ProgramSql, ProgramStore, ProcessEvents, Publishable, System, SystemUploads, Upload, Size, Subscribable, SubscribableEvents, SubscribableFallback, TimedAskable, Timeoutable, Appearance, AppearanceEvents, AppearanceSource, AppearanceSurface, AnimationsPreference, DesktopPreferences, DesktopPreferencesEvents, DesktopPreferencesSource, DesktopPreferencesUpdate, Desktop, DesktopSize, DesktopSurfaceEvents, DesktopSurfaceSnapshot, DesktopSurfaceSource, WritableDesktopPreferencesSource, ThemedValue, Theme, ThemePreference, Value, WindowEvents, WindowGeometry, WindowLayer, WindowState, Easing, LocalWindow, LocalWindowOperations, Transaction } from "@phreshos/core";
+export { context } from "./context.js";

package/dist/main.js

@@ -1,5 +1,3 @@
 export { system } from "./system.js";
 export { desktop } from "./desktop/desktop.js";
 export { context } from "./context.js";
-export { ClientService, ServerService, Service, clientPermissionCatalog, isPermissionName, } from "@phreshos/core";
-export { ClientEndpoint, Endpoint, Process, Program, ServerEndpoint } from "./domain.js";

package/dist/network.d.ts

@@ -0,0 +1,7 @@
+import type { Network } from "@phreshos/core";
+declare class ClientNetwork implements Network {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    websocket(url: string | URL, protocols?: string | string[]): Promise<WebSocket>;
+}
+declare const _default: ClientNetwork;
+export default _default;

package/dist/network.js

@@ -0,0 +1,79 @@
+import wire from "./wire.js";
+import controlledStream from "./controlled-stream.js";
+import websocket from "./websocket.js";
+class ClientNetwork {
+    async fetch(input, init) {
+        const request = new Request(input, {
+            ...init,
+            ...init?.body instanceof ReadableStream ? { duplex: "half" } : {}
+        });
+        const body = request.body;
+        const control = new MessageChannel();
+        const abort = () => control.port1.postMessage("abort");
+        if (request.signal.aborted) {
+            control.port1.close();
+            control.port2.close();
+            throw request.signal.reason;
+        }
+        request.signal.addEventListener("abort", abort, { once: true });
+        const description = {
+            body: body !== null,
+            cache: request.cache,
+            credentials: request.credentials,
+            headers: requestHeaders(request.headers, init?.headers),
+            integrity: request.integrity,
+            keepalive: request.keepalive,
+            method: request.method,
+            mode: request.mode,
+            redirect: request.redirect,
+            referrer: request.referrer,
+            referrerPolicy: request.referrerPolicy,
+            url: request.url
+        };
+        let result;
+        try {
+            const answer = await wire.request(["fetch", description, body, control.port2], undefined, body ? [body, control.port2] : [control.port2]);
+            result = answer[0];
+        }
+        catch (error) {
+            abort();
+            closeControl(request.signal, control.port1, abort);
+            throw request.signal.aborted ? request.signal.reason : error;
+        }
+        const responseBody = result.body
+            ? controlledStream(result.body, abort, () => closeControl(request.signal, control.port1, abort))
+            : null;
+        if (!responseBody)
+            closeControl(request.signal, control.port1, abort);
+        const response = new Response(responseBody, {
+            headers: result.headers,
+            status: result.status,
+            statusText: result.statusText
+        });
+        Object.defineProperties(response, {
+            redirected: { configurable: true, enumerable: true, value: result.redirected },
+            type: { configurable: true, enumerable: true, value: result.type },
+            url: { configurable: true, enumerable: true, value: result.url }
+        });
+        return response;
+    }
+    websocket(url, protocols) {
+        return websocket(url, protocols);
+    }
+}
+function requestHeaders(normalized, supplied) {
+    if (!supplied)
+        return [...normalized.entries()];
+    const explicit = supplied instanceof Headers
+        ? [...supplied.entries()]
+        : Array.isArray(supplied)
+            ? supplied.map(([name, value]) => [name, value])
+            : Object.entries(supplied);
+    const names = new Set(explicit.map(([name]) => name.toLowerCase()));
+    return [...normalized.entries()].filter(([name]) => !names.has(name.toLowerCase())).concat(explicit);
+}
+function closeControl(signal, port, abort) {
+    signal.removeEventListener("abort", abort);
+    port.close();
+}
+export default new ClientNetwork();

package/dist/permissions.d.ts

@@ -1,7 +1,7 @@
 import type { ContextPermissions, ProgramPermissions } from "@phreshos/core";
 import type { HandleAddress } from "./domain.js";
 export declare const defaultPermissionTimeout = 120000;
-/** Bind authoritative stored grants to one exact Program handle. */
+/** Bind authoritative permission state to one exact Program handle. */
 export declare function programPermissions(program: HandleAddress): ProgramPermissions;
-/** Stored grants and owner requests belonging to the current Client Endpoint. */
+/** Permission state and owner requests belonging to the current Client Endpoint. */
 export declare function contextPermissions(): ContextPermissions;

package/dist/permissions.js

@@ -1,7 +1,7 @@
 import { parsePermission, parsePermissions } from "@phreshos/core";
 import wire from "./wire.js";
 export const defaultPermissionTimeout = 120_000;
-/** Bind authoritative stored grants to one exact Program handle. */
+/** Bind authoritative permission state to one exact Program handle. */
 export function programPermissions(program) {
     const operate = (operation, name, permission) => (wire.request(["program-permissions", program, operation, name, permission]));
     return {
@@ -12,7 +12,7 @@ export function programPermissions(program) {
         async delete(name) { await operate("delete", name); }
     };
 }
-/** Stored grants and owner requests belonging to the current Client Endpoint. */
+/** Permission state and owner requests belonging to the current Client Endpoint. */
 export function contextPermissions() {
     const timed = (timeout) => ({
         async request(name, permission = true) {

package/dist/service.js

@@ -4,8 +4,6 @@ import Events from "./events.js";
 import HandleRegistry from "./handle-registry.js";
 import wire from "./wire.js";
 const handles = new HandleRegistry();
-const ServerServiceBase = CoreServerService;
-const ClientServiceBase = CoreClientService;
 class ServiceHandle {
     key;
     lifecycle;
@@ -24,8 +22,11 @@ class ServiceHandle {
         await wire.request(["service-wait-ready", this.key, timeout], timeout);
     }
 }
-class ServerHandler extends ServerServiceBase {
+class ServerHandler extends CoreServerService {
     key;
+    subscribe;
+    wait;
+    events;
     lifecycle;
     service;
     constructor(key) {
@@ -33,9 +34,12 @@ class ServerHandler extends ServerServiceBase {
         this.key = key;
         this.service = new ServiceHandle(key);
         this.lifecycle = this.service.lifecycle;
-        bindEvents(this, new Events(...serviceEvents(key, "events")));
+        const events = new Events(...serviceEvents(key, "events"));
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
-    publish(event, payload = undefined) { this.service.publish(event, payload); }
+    publish = (event, payload = undefined) => { this.service.publish(event, payload); };
     exists() { return this.service.exists(); }
     waitReady(timeout) { return this.service.waitReady(timeout); }
     async ask(event, payload = undefined) {
@@ -58,31 +62,39 @@ class ServerHandler extends ServerServiceBase {
         }
     }
 }
-class ClientHandler extends ClientServiceBase {
+class ClientHandler extends CoreClientService {
+    subscribe;
+    wait;
+    events;
     lifecycle;
     service;
     constructor(key) {
         super();
         this.service = new ServiceHandle(key);
         this.lifecycle = this.service.lifecycle;
-        bindEvents(this, new Events(...serviceEvents(key, "events")));
+        const events = new Events(...serviceEvents(key, "events"));
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
-    publish(event, payload = undefined) { this.service.publish(event, payload); }
+    publish = (event, payload = undefined) => { this.service.publish(event, payload); };
     exists() { return this.service.exists(); }
     waitReady(timeout) { return this.service.waitReady(timeout); }
 }
 export function prepareService(key) {
     if (!isServiceKey(key))
         throw new Error("A complete service key is required");
-    const normalized = Object.freeze({
+    const address = Object.freeze({
         ...(key.program === undefined ? {} : { program: key.program }),
-        process: key.process,
-        endpoint: key.endpoint
+        process: key.process
     });
     const identity = JSON.stringify([key.program ?? null, key.process, key.endpoint]);
-    return handles.obtain(`service:${identity}`, () => normalized.endpoint === "server"
-        ? new ServerHandler(normalized)
-        : new ClientHandler(normalized));
+    if (key.endpoint === "server") {
+        const normalized = Object.freeze({ ...address, endpoint: "server" });
+        return handles.obtain(`service:${identity}`, () => new ServerHandler(normalized));
+    }
+    const normalized = Object.freeze({ ...address, endpoint: "client" });
+    return handles.obtain(`service:${identity}`, () => new ClientHandler(normalized));
 }
 function serviceEvents(key, scope) {
     return [
@@ -93,10 +105,3 @@ function serviceEvents(key, scope) {
         }, impossible)
     ];
 }
-function bindEvents(target, events) {
-    Object.assign(target, {
-        subscribe: events.subscribe.bind(events),
-        waitFor: events.waitFor.bind(events),
-        events: events.events.bind(events)
-    });
-}

package/dist/storage.d.ts

@@ -1,9 +1,8 @@
-import type { ProgramSql, ProgramStore, Storage as CoreStorage } from "@phreshos/core";
+import { Storage, type ProgramSql, type ProgramStore } from "@phreshos/core";
 import type { HandleAddress } from "./domain.js";
-export type Storage = CoreStorage;
 /** Client-side access to one exact Program storage area. */
 export declare function area(program: HandleAddress, which: "data" | "cache"): Storage;
-export declare function store(program: HandleAddress): ProgramStore;
-export declare function sql(kind: "database" | "logs", program: HandleAddress): ProgramSql;
 /** Access to the System's native storage through the Client boundary. */
 export declare function systemStorage(): Storage;
+export declare function store(program: HandleAddress): ProgramStore;
+export declare function sql(kind: "database" | "logs", program: HandleAddress): ProgramSql;

package/dist/storage.js

@@ -1,53 +1,202 @@
+import { Storage, StorageFile } from "@phreshos/core";
 import { content } from "./content.js";
 import controlledStream from "./controlled-stream.js";
 import wire from "./wire.js";
 /** Client-side access to one exact Program storage area. */
 export function area(program, which) {
-    async function ask(operation, ...values) {
-        const answer = await wire.request([which, program, operation, ...values]);
+    return new RemoteStorage(new ProgramStorageBoundary(program, which), []);
+}
+/** Access to the System's native storage through the Client boundary. */
+export function systemStorage() {
+    return new RemoteStorage(new SystemStorageBoundary(), []);
+}
+class StorageBoundary {
+}
+class ProgramStorageBoundary extends StorageBoundary {
+    program;
+    area;
+    constructor(program, area) {
+        super();
+        this.program = program;
+        this.area = area;
+    }
+    async ask(operation, path, input) {
+        const answer = await wire.request([this.area, this.program, operation, [...path], input]);
         return answer[0];
     }
-    async function transfer(operation, path, body = null) {
-        const channel = new MessageChannel();
-        const abort = () => channel.port1.postMessage("abort");
-        const close = () => channel.port1.close();
-        try {
-            const answer = await wire.request([which, program, operation, path, body, channel.port2], undefined, body instanceof ReadableStream ? [body, channel.port2] : [channel.port2]);
-            if (operation === "write") {
-                close();
-                return null;
-            }
-            if (!(answer[0] instanceof ReadableStream))
-                throw new Error("The storage response has no byte stream");
-            return controlledStream(answer[0], abort, close);
-        }
-        catch (error) {
-            abort();
-            close();
-            throw error;
-        }
+    transfer(operation, path, body, input) {
+        return transfer([this.area, this.program, operation], path, body, input);
+    }
+    watch(path, options, signal) {
+        return watch(["program", this.program, this.area, [...path], options], signal);
+    }
+}
+class SystemStorageBoundary extends StorageBoundary {
+    async ask(operation, path, input) {
+        const answer = await wire.request(["host-storage", operation, [...path], input]);
+        return answer[0];
+    }
+    transfer(operation, path, body, input) {
+        return transfer([`host-storage-${operation}`], path, body, input);
     }
-    async function stream(...path) {
-        const body = await transfer("stream", path);
+    watch(path, options, signal) {
+        return watch(["system", [...path], options], signal);
+    }
+}
+class RemoteStorage extends Storage {
+    boundary;
+    parts;
+    constructor(boundary, parts) {
+        super();
+        this.boundary = boundary;
+        this.parts = parts;
+    }
+    name() { return this.boundary.ask("name", this.parts); }
+    path() { return this.boundary.ask("path", this.parts); }
+    navigate(...parts) { return new RemoteStorage(this.boundary, [...this.parts, ...parts]); }
+    file(...parts) { return new RemoteStorageFile(this.boundary, [...this.parts, ...parts]); }
+    create() { return this.boundary.ask("create", this.parts); }
+    stat() { return this.boundary.ask("stat-storage", this.parts); }
+    async list(options = {}) {
+        const values = await this.boundary.ask("list", this.parts, options);
+        if (!Array.isArray(values))
+            throw new Error("The System returned an invalid Storage list");
+        return values.map(value => {
+            const entry = parseEntry(value);
+            return entry.kind === "file"
+                ? new RemoteStorageFile(this.boundary, [...this.parts, ...entry.path])
+                : new RemoteStorage(this.boundary, [...this.parts, ...entry.path]);
+        });
+    }
+    copy(destination, options = {}) { return copyStorage(this, destination, options); }
+    async move(destination, options = {}) {
+        if (await sameLocation(this, destination))
+            return;
+        await copyStorage(this, destination, options);
+        await this.delete();
+    }
+    delete() { return this.boundary.ask("delete-storage", this.parts); }
+    clear() { return this.boundary.ask("clear", this.parts); }
+    space() { return this.boundary.ask("space", this.parts); }
+    watch(options = {}) {
+        return this.boundary.watch(this.parts, { recursive: options.recursive }, options.signal);
+    }
+}
+class RemoteStorageFile extends StorageFile {
+    boundary;
+    parts;
+    constructor(boundary, parts) {
+        super();
+        this.boundary = boundary;
+        this.parts = parts;
+    }
+    name() { return this.boundary.ask("name", this.parts); }
+    path() { return this.boundary.ask("path", this.parts); }
+    stat() { return this.boundary.ask("stat-file", this.parts); }
+    async stream(options = {}) {
+        const body = await this.boundary.transfer("stream", this.parts, undefined, options);
         if (!body)
-            throw new Error("The storage response has no body");
+            throw new Error("The Storage response has no byte stream");
         return body;
     }
-    return {
-        path: () => ask("path"),
-        resolve: (...path) => ask("resolve", ...path),
-        stream,
-        async bytes(...path) { return new Uint8Array(await new Response(await stream(...path)).arrayBuffer()); },
-        async text(...path) { return new Response(await stream(...path)).text(); },
-        async json(...path) { return JSON.parse(await new Response(await stream(...path)).text()); },
-        async write(...args) {
-            await transfer("write", args.slice(0, -1), content(args.at(-1)).body);
-        },
-        stat: (...path) => ask("stat", ...path),
-        list: (...path) => ask("list", ...path),
-        delete: (...path) => ask("delete", ...path),
-        clear: (...path) => ask("clear", ...path)
-    };
+    async bytes(options) {
+        return new Uint8Array(await new Response(await this.stream(options)).arrayBuffer());
+    }
+    async text(options) {
+        return new Response(await this.stream(options)).text();
+    }
+    async json() { return JSON.parse(await this.text()); }
+    async write(value, options = {}) {
+        await this.boundary.transfer("write", this.parts, content(value).body, options);
+    }
+    async append(value) {
+        await this.boundary.transfer("append", this.parts, content(value).body);
+    }
+    async copy(destination, options = {}) {
+        if (await sameLocation(this, destination))
+            return;
+        await destination.write(await this.stream(), { overwrite: options.overwrite ?? false });
+    }
+    async move(destination, options = {}) {
+        if (await sameLocation(this, destination))
+            return;
+        await this.copy(destination, options);
+        await this.delete();
+    }
+    delete() { return this.boundary.ask("delete-file", this.parts); }
+}
+async function transfer(prefix, path, body, input) {
+    const channel = new MessageChannel();
+    const abort = () => channel.port1.postMessage("abort");
+    const close = () => channel.port1.close();
+    try {
+        const answer = await wire.request([...prefix, [...path], body ?? null, channel.port2, input], undefined, body instanceof ReadableStream ? [body, channel.port2] : [channel.port2]);
+        if (prefix.at(-1) !== "stream") {
+            close();
+            return null;
+        }
+        if (!(answer[0] instanceof ReadableStream))
+            throw new Error("The Storage response has no byte stream");
+        return controlledStream(answer[0], abort, close);
+    }
+    catch (error) {
+        abort();
+        close();
+        throw error;
+    }
+}
+function watch(values, signal) {
+    const operation = wire.stream(["storage-watch", ...values], undefined, signal);
+    return (async function* () {
+        for await (const value of operation) {
+            const change = value;
+            if (!change || (change.event !== "change" && change.event !== "rename") || change.path !== null && typeof change.path !== "string") {
+                throw new Error("The System returned an invalid Storage change");
+            }
+            yield Object.freeze({ event: change.event, path: change.path });
+        }
+    })();
+}
+async function copyStorage(source, destination, options) {
+    if (await sameLocation(source, destination))
+        return;
+    const [sourcePath, destinationPath] = await Promise.all([source.path(), destination.path()]);
+    if (descendsFrom(destinationPath, sourcePath))
+        throw new Error("A Storage directory cannot be copied inside itself");
+    if (!await source.stat())
+        throw new Error(`There is no Storage directory at ${sourcePath}`);
+    if (await destination.stat()) {
+        if (!options.overwrite)
+            throw new Error(`A Storage directory already exists at ${destinationPath}`);
+        await destination.delete();
+    }
+    await destination.create();
+    for (const entry of await source.list()) {
+        const name = await entry.name();
+        if (entry instanceof StorageFile)
+            await entry.copy(destination.file(name), options);
+        else
+            await entry.copy(destination.navigate(name), options);
+    }
+}
+async function sameLocation(left, right) {
+    const [leftPath, rightPath] = await Promise.all([left.path(), right.path()]);
+    return normalizePath(leftPath) === normalizePath(rightPath);
+}
+function descendsFrom(path, parent) {
+    const normalized = normalizePath(path);
+    const root = normalizePath(parent);
+    return normalized.startsWith(`${root}/`);
+}
+function normalizePath(path) {
+    return path.replaceAll("\\", "/").replace(/\/+$/, "");
+}
+function parseEntry(value) {
+    const entry = value;
+    if (!entry || (entry.kind !== "storage" && entry.kind !== "file") || !Array.isArray(entry.path) || entry.path.length === 0 || entry.path.some(part => typeof part !== "string")) {
+        throw new Error("The System returned an invalid Storage entry");
+    }
+    return { kind: entry.kind, path: entry.path };
 }
 export function store(program) {
     async function ask(operation, ...values) {
@@ -72,52 +221,3 @@ export function sql(kind, program) {
         }
     };
 }
-/** Access to the System's native storage through the Client boundary. */
-export function systemStorage() {
-    async function ask(operation, ...values) {
-        const answer = await wire.request(["host-storage", operation, ...values]);
-        return answer[0];
-    }
-    async function transfer(operation, path, body = null) {
-        const channel = new MessageChannel();
-        const abort = () => channel.port1.postMessage("abort");
-        const close = () => channel.port1.close();
-        try {
-            const answer = await wire.request([`host-storage-${operation}`, path, body, channel.port2], undefined, body instanceof ReadableStream ? [body, channel.port2] : [channel.port2]);
-            if (operation === "write") {
-                close();
-                return null;
-            }
-            if (!(answer[0] instanceof ReadableStream))
-                throw new Error("The storage response has no byte stream");
-            return controlledStream(answer[0], abort, close);
-        }
-        catch (error) {
-            abort();
-            close();
-            throw error;
-        }
-    }
-    async function stream(...path) {
-        const body = await transfer("stream", path);
-        if (!body)
-            throw new Error("The storage response has no body");
-        return body;
-    }
-    return {
-        path: () => ask("path"),
-        resolve: (...path) => ask("resolve", ...path),
-        stream,
-        async bytes(...path) { return new Uint8Array(await new Response(await stream(...path)).arrayBuffer()); },
-        async text(...path) { return new Response(await stream(...path)).text(); },
-        async json(...path) { return JSON.parse(await new Response(await stream(...path)).text()); },
-        async write(...args) {
-            const path = args.slice(0, -1);
-            await transfer("write", path, content(args.at(-1)).body);
-        },
-        stat: (...path) => ask("stat", ...path),
-        list: (...path) => ask("list", ...path),
-        delete: (...path) => ask("delete", ...path),
-        clear: (...path) => ask("clear", ...path)
-    };
-}