@phreshos/client 0.1.49 → 0.1.51

package/dist/context.js

@@ -2,7 +2,7 @@ import Deadline from "./deadline.js";
 import { ClientEndpoint, ServerEndpoint, ServerTrafficHandle, TrafficHandle, endpointLifecycle, endpointEvents, process, program, visibleEndpoint, presentation, window as windowHandle, } from "./domain.js";
 import Events from "./events.js";
 import wire from "./wire.js";
-import { programPermissions } from "./permissions.js";
+import { contextPermissions } from "./permissions.js";
 class ContextServerHandle extends ServerEndpoint {
     owner;
     subscribe;
@@ -96,7 +96,7 @@ class ClientContext extends Events {
     server = contextServer;
     window = contextClient.window;
     presentation = presentation(currentAddress);
-    permissions = programPermissions();
+    permissions = contextPermissions();
     constructor() {
         super((event, listener, impossible) => wire.on("end-end", event, value => listener(contextMessage(value)), null, impossible), (listener, impossible) => wire.onAll("end-end", (event, value) => {
             if (typeof event === "string")

package/dist/domain.js

@@ -2,7 +2,7 @@ import { ClientEndpoint as CoreClientEndpoint, Endpoint as CoreEndpoint, Process
 import Events, { stream } from "./events.js";
 import Deadline from "./deadline.js";
 import HandleRegistry from "./handle-registry.js";
-import { area, sql, store } from "./storage.js";
+import { area, programLogs, sql, store } from "./storage.js";
 import startup from "./startup.js";
 import { programPermissions } from "./permissions.js";
 import wire from "./wire.js";
@@ -29,7 +29,7 @@ class ProgramHandle extends CoreProgram {
         this.data = area(this.address, "data");
         this.cache = area(this.address, "cache");
         this.store = store(this.address);
-        this.logs = sql("logs", this.address);
+        this.logs = programLogs(this.address);
         this.database = sql("database", this.address);
         this.startup = startup(this.address);
         this.permissions = programPermissions(this.address);
@@ -321,8 +321,6 @@ class WindowHandle extends Events {
     }
     async title() { return (await this.state()).title; }
     async header() { return (await this.state()).header; }
-    async surface() { return (await this.state()).surface; }
-    async transaction() { return (await this.state()).transaction; }
     async position() { return (await this.state()).position; }
     async size() { return (await this.state()).size; }
     async minimized() { return (await this.state()).minimized; }
@@ -336,24 +334,12 @@ class WindowHandle extends Events {
     async maximize(maximized = true) { await wire.request(["maximize", await this.target(), maximized]); }
     async setTitle(title) { await wire.request(["setTitle", await this.target(), title]); }
     async setHeader(header) { await wire.request(["setHeader", await this.target(), header]); }
-    async setSurface(surface) { await wire.request(["setSurface", await this.target(), surface]); }
-    async setTransaction(transaction) { await wire.request(["setTransaction", await this.target(), transaction]); }
     async raise() { await wire.request(["raise", await this.target()]); }
 }
-class WindowPresentationHandle extends Events {
+class WindowPresentationHandle {
     target;
     selected;
     constructor(target, selected) {
-        super((event, listener, impossible) => {
-            if (!windowEvent(event)) {
-                impossible?.(new Error(`A Window presentation has no "${event}" event`));
-                return () => undefined;
-            }
-            return wire.on("presentation", event, listener, null, impossible);
-        }, (listener, impossible) => wire.onAll("presentation", (event, ...values) => {
-            if (typeof event === "string")
-                listener(event, values[0]);
-        }, null, impossible));
         this.target = target;
         this.selected = selected;
     }
@@ -363,32 +349,50 @@ class WindowPresentationHandle extends Events {
     transactionAndWait(transaction) {
         return new WindowPresentationHandle(this.target, { transaction, wait: true });
     }
-    async title() { return await this.read("title"); }
-    async header() { return await this.read("header"); }
-    async surface() { return await this.read("surface"); }
-    async position() { return await this.read("position"); }
-    async size() { return await this.read("size"); }
-    async minimized() { return await this.read("minimized"); }
-    async maximized() { return await this.read("maximized"); }
-    async front() { return await this.read("front"); }
-    async layer() { return await this.read("layer"); }
+    async layer() {
+        const answer = await wire.request(["windowPresentationLayer", await this.target()]);
+        return answer[0];
+    }
+    beginMoveGesture(start) {
+        return new WindowMoveGestureHandle(this.target(), start);
+    }
     async move(position) { await this.change("windowPresentationMove", position); }
     async resize(size) { await this.change("windowPresentationResize", size); }
     async setGeometry(geometry) { await this.change("windowPresentationGeometry", geometry); }
-    async minimize(minimized = true) { await this.change("windowPresentationMinimize", minimized); }
-    async maximize(maximized = true) { await this.change("windowPresentationMaximize", maximized); }
-    async setTitle(title) { await this.change("windowPresentationTitle", title); }
-    async setHeader(header) { await this.change("windowPresentationHeader", header); }
     async setSurface(surface) { await this.change("windowPresentationSurface", surface); }
-    async follow() { await this.change("windowPresentationFollow"); }
-    async unfollow() { await this.change("windowPresentationUnfollow"); }
+    async setInteractive(interactive) { await this.change("windowPresentationInteractive", interactive); }
     async raise() { await this.change("windowPresentationRaise"); }
     async change(operation, value) {
-        await wire.request([operation, await this.target(), value, this.selected?.transaction, this.selected?.wait === true]);
+        await wire.request([operation, await this.target(), value, this.selected ?? null]);
     }
-    async read(property) {
-        const answer = await wire.request(["windowPresentationRead", await this.target(), property]);
-        return answer[0];
+}
+class WindowMoveGestureHandle {
+    gesture = crypto.randomUUID();
+    address;
+    ready;
+    finished;
+    ended = false;
+    constructor(target, start) {
+        this.address = target;
+        this.ready = target.then(async (address) => {
+            await wire.request(["windowPresentationMoveGestureBegin", address, this.gesture, start]);
+        });
+        this.finished = this.ready.then(async () => {
+            await wire.request(["windowPresentationMoveGestureWait", await this.address, this.gesture]);
+        });
+        // A gesture may be abandoned by document teardown before its owner can end
+        // it. The boundary still owns cleanup; this only prevents an unhandled rejection.
+        void this.finished.catch(() => undefined);
+        void this.finished.then(() => { this.ended = true; }, () => { this.ended = true; });
+    }
+    cancel() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        void this.ready.then(async () => {
+            const address = await this.address;
+            wire.send("end-host", "windowPresentationMoveGestureCancel", address, this.gesture);
+        }, () => undefined);
     }
 }
 function deferredScoped(route, target, convert) {
@@ -414,7 +418,7 @@ function deferredScoped(route, target, convert) {
     ];
 }
 function windowEvent(event) {
-    return event === "move" || event === "resize" || event === "minimize" || event === "maximize" || event === "changeTitle" || event === "changeHeader" || event === "changeSurface" || event === "changeTransaction" || event === "front";
+    return event === "move" || event === "resize" || event === "minimize" || event === "maximize" || event === "changeTitle" || event === "changeHeader" || event === "front";
 }
 function deferred(target, register, impossible) {
     let active = true;

package/dist/permission-requests.d.ts

@@ -0,0 +1,2 @@
+import { type SystemPermissions } from "@phreshos/core";
+export declare const systemPermissions: SystemPermissions;

package/dist/permission-requests.js

@@ -0,0 +1,84 @@
+import { PermissionRequest as CorePermissionRequest, parsePermission, parsePermissionRequestSnapshot } from "@phreshos/core";
+import { endpoint } from "./domain.js";
+import Events from "./events.js";
+import wire from "./wire.js";
+const handles = new Map();
+class PermissionRequestHandle extends CorePermissionRequest {
+    subscribe;
+    wait;
+    events;
+    identity;
+    from;
+    createdAt;
+    expiresAt;
+    name;
+    scope;
+    constructor(snapshot) {
+        super();
+        this.identity = snapshot.identity;
+        this.from = endpoint(snapshot.from);
+        this.createdAt = snapshot.createdAt;
+        this.expiresAt = snapshot.expiresAt;
+        this.name = snapshot.name;
+        this.scope = snapshot.scope;
+        const events = new Events((event, listener, impossible) => wire.on("permission-host", event, (...values) => {
+            listener(parsePermission(this.name, values[2]));
+        }, this.identity, impossible), (listener, impossible) => wire.onAll("permission-host", (event, ...values) => {
+            if (event === "resolve")
+                listener(event, parsePermission(this.name, values[2]));
+        }, this.identity, impossible));
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
+    }
+    async pending() {
+        const answer = await wire.request(["permission-request-pending", this.identity]);
+        return answer[0] === true;
+    }
+    async allow() { await wire.request(["permission-request-allow", this.identity]); }
+    async deny() { await wire.request(["permission-request-deny", this.identity]); }
+    async cancel() { await wire.request(["permission-request-cancel", this.identity]); }
+}
+function requestHandle(value) {
+    const snapshot = parsePermissionRequestSnapshot(value);
+    const current = handles.get(snapshot.identity);
+    if (current)
+        return current;
+    const created = new PermissionRequestHandle(snapshot);
+    handles.set(snapshot.identity, created);
+    return created;
+}
+class PermissionRegistry extends Events {
+    constructor() {
+        super((event, listener, impossible) => wire.on("host-permission", permissionEvent(event), (...values) => {
+            listener(systemPermissionEvent(event, values));
+        }, null, impossible), (listener, impossible) => wire.onAll("host-permission", (event, ...values) => {
+            if (typeof event !== "string")
+                return;
+            const name = publicPermissionEvent(event);
+            if (name)
+                listener(name, systemPermissionEvent(name, values));
+        }, null, impossible));
+    }
+    async requests() {
+        const [values] = await wire.request(["host-permission-requests"]);
+        return values.map(requestHandle);
+    }
+}
+function permissionEvent(event) {
+    return event === "permissionRequest" ? "request" : "resolve";
+}
+function publicPermissionEvent(event) {
+    if (event === "request")
+        return "permissionRequest";
+    if (event === "resolve")
+        return "permissionResolve";
+    return null;
+}
+function systemPermissionEvent(event, values) {
+    const request = requestHandle(values[1]);
+    if (event === "permissionRequest")
+        return request;
+    return { request, permission: parsePermission(request.name, values[2]) };
+}
+export const systemPermissions = new PermissionRegistry();

package/dist/permissions.d.ts

@@ -1,5 +1,6 @@
-import type { ProgramPermissions } from "@phreshos/core";
+import type { ContextPermissions, ProgramPermissions } from "@phreshos/core";
 import type { HandleAddress } from "./domain.js";
-export declare const defaultPermissionTimeout = 120000;
 /** Bind authoritative permission state to one exact Program handle. */
 export declare function programPermissions(program?: HandleAddress): ProgramPermissions;
+/** Bind permission reads and requests to the currently executing Client Endpoint. */
+export declare function contextPermissions(): ContextPermissions;

package/dist/permissions.js

@@ -1,23 +1,34 @@
 import { parsePermission, parsePermissions } from "@phreshos/core";
 import wire from "./wire.js";
-export const defaultPermissionTimeout = 120_000;
 /** 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 {
+        async get(name) { return parsePermission(name, (await operate("get", name))[0]); },
+        async all() { return parsePermissions((await operate("all"))[0]); },
+        async allows(name, permission = true) { return (await operate("allows", name, permission))[0] === true; },
+        async allow(name, permission = true) { await operate("allow", name, permission); },
+        async deny(name) { await operate("deny", name); }
+    };
+}
+/** Bind permission reads and requests to the currently executing Client Endpoint. */
+export function contextPermissions() {
+    const operate = (operation, name, permission) => (wire.request(["program-permissions", undefined, operation, name, permission]));
     const timed = (timeout) => ({
         async request(name, permission = true) {
             const identity = crypto.randomUUID();
-            const result = await wire.requestOrNull(["program-permissions", program, "request", identity, name, permission], timeout);
-            return result === null ? null : parsePermission(name, result[0]);
+            const request = ["context-permission-request", identity, name, permission];
+            if (timeout !== undefined)
+                request.push(timeout);
+            const result = await wire.request(request);
+            return parsePermission(name, result[0]);
         }
     });
     return {
         async get(name) { return parsePermission(name, (await operate("get", name))[0]); },
         async all() { return parsePermissions((await operate("all"))[0]); },
         async allows(name, permission = true) { return (await operate("allows", name, permission))[0] === true; },
-        async allow(name, permission = true) { await operate("allow", name, permission); },
-        async deny(name) { await operate("deny", name); },
-        request: timed(defaultPermissionTimeout).request,
+        request: timed().request,
         timeout(milliseconds) {
             if (!Number.isFinite(milliseconds) || milliseconds < 0)
                 throw new Error("A permission timeout must be a non-negative finite number");

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import { Storage, type ProgramSql, type ProgramStore } from "@phreshos/core";
+import { Storage, type ProgramLogs, type ProgramSql, type ProgramStore, type SystemLogs } from "@phreshos/core";
 import type { HandleAddress } from "./domain.js";
 /** Client-side access to one exact Program storage area. */
 export declare function area(program: HandleAddress, which: "data" | "cache"): Storage;
@@ -6,3 +6,7 @@ export declare function area(program: HandleAddress, which: "data" | "cache"): S
 export declare function systemStorage(): Storage;
 export declare function store(program: HandleAddress): ProgramStore;
 export declare function sql(kind: "database" | "logs", program: HandleAddress): ProgramSql;
+/** Read and observe one Program's captured Endpoint output. */
+export declare function programLogs(program: HandleAddress): ProgramLogs;
+/** Read and observe records produced by the PhreshOS System. */
+export declare function systemLogs(): SystemLogs;

package/dist/storage.js

@@ -1,7 +1,8 @@
-import { Storage, StorageFile } from "@phreshos/core";
+import { Storage, StorageFile, parseProgramLogRecord, parseSystemLogRecord } from "@phreshos/core";
 import { content } from "./content.js";
 import controlledStream from "./controlled-stream.js";
 import wire from "./wire.js";
+import Events from "./events.js";
 /** Client-side access to one exact Program storage area. */
 export function area(program, which) {
     return new RemoteStorage(new ProgramStorageBoundary(program, which), []);
@@ -221,3 +222,35 @@ export function sql(kind, program) {
         }
     };
 }
+/** Read and observe one Program's captured Endpoint output. */
+export function programLogs(program) {
+    const database = sql("logs", program);
+    const events = new Events((event, listener, impossible) => wire.on("program-log", event, (...values) => listener(parseProgramLogRecord(values[1])), program.reference, impossible), (listener, impossible) => wire.onAll("program-log", (event, ...values) => {
+        if (event === "log")
+            listener(event, parseProgramLogRecord(values[1]));
+    }, program.reference, impossible));
+    return {
+        query: database.query,
+        subscribe: events.subscribe,
+        wait: events.wait,
+        events: events.events
+    };
+}
+/** Read and observe records produced by the PhreshOS System. */
+export function systemLogs() {
+    const events = new Events((event, listener, impossible) => wire.on("host-log", event, (...values) => listener(parseSystemLogRecord(values[1])), null, impossible), (listener, impossible) => wire.onAll("host-log", (event, ...values) => {
+        if (event === "log")
+            listener(event, parseSystemLogRecord(values[1]));
+    }, null, impossible));
+    return {
+        async query(statement, ...rest) {
+            const text = typeof statement === "string" ? statement : statement.raw.join("?");
+            const values = typeof statement === "string" ? (Array.isArray(rest[0]) ? rest[0] : []) : rest;
+            const answer = await wire.request(["system-logs", text, values]);
+            return answer[0];
+        },
+        subscribe: events.subscribe,
+        wait: events.wait,
+        events: events.events
+    };
+}

package/dist/system.js

@@ -5,15 +5,18 @@ import { prepareService } from "./service.js";
 import { uploads } from "./uploads.js";
 import Events from "./events.js";
 import { exit, process, program } from "./domain.js";
-import { systemStorage } from "./storage.js";
+import { systemLogs, systemStorage } from "./storage.js";
 import network from "./network.js";
 import { connection, session } from "./authentication.js";
+import { systemPermissions } from "./permission-requests.js";
 class ClientSystem {
     storage = systemStorage();
     appearance = new ClientAppearance();
     program = new SystemProgramHandle();
     process = new SystemProcessHandle();
     authentication = new SystemAuthenticationHandle();
+    permissions = systemPermissions;
+    logs = systemLogs();
     service = new SystemServiceHandle();
     uploads = uploads;
     network = network;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/client",
-    "version": "0.1.49",
+  "version": "0.1.51",
   "description": "The SDK used by a Program's client endpoint.",
   "type": "module",
   "main": "dist/main.js",
@@ -46,13 +46,13 @@
     "test": "vitest run --project default"
   },
   "peerDependencies": {
-        "@phreshos/core": "^0.1.58"
+    "@phreshos/core": "^0.1.60"
   },
   "dependencies": {
     "@the-link/messagepack": "^0.1.0"
   },
   "devDependencies": {
-        "@phreshos/core": "^0.1.58",
+        "@phreshos/core": "^0.1.60",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }