@phreshos/client 0.1.6 → 0.1.8

package/dist/desktop.d.ts

@@ -1,20 +1,25 @@
-import type { Size, Subscribable } from "@phreshos/core";
+import type { Subscribable } from "@phreshos/core";
 import Events from "./events.js";
+/** The complete measured desktop area in CSS pixels. */
+export type DesktopSize = Readonly<{
+    width: number;
+    height: number;
+}>;
 /** Live changes to the desktop area containing this Client. */
 export type DesktopEvents = {
     /** The desktop area resized. */
-    resize: Size;
+    resize: DesktopSize;
 };
 /** Explicit desktop size reads and future resizes. */
 export interface HostDesktop extends Subscribable<DesktopEvents, never> {
     /** Reads the complete current desktop area in CSS pixels. */
-    size(): Promise<Size>;
+    size(): Promise<DesktopSize>;
 }
 /** Desktop access bound to the current Client Process boundary. */
 export default class ClientDesktop extends Events {
     constructor();
     size(): Promise<Readonly<{
-        width: import("@phreshos/core").Value;
-        height: import("@phreshos/core").Value;
+        width: number;
+        height: number;
     }>>;
 }

package/dist/main.d.ts

@@ -1,6 +1,6 @@
 export { host, type Host } from "./host.js";
 export { type HostPointer, type PointerEvents, type PointerPosition } from "./pointer.js";
-export { type DesktopEvents, type HostDesktop } from "./desktop.js";
+export { type DesktopEvents, type DesktopSize, type HostDesktop } from "./desktop.js";
 export { current, type Current, type CurrentServer } from "./current.js";
 export { type Channel, type ChannelCapture, type ChannelEvents, type ChannelMessage } from "./channel.js";
 export { ClientServiceHandler, ServerServiceHandler, ServiceHandler, type ClientServiceChannel, type ServerServiceChannel, type ServiceChannel, type ServiceKey, type ServiceLifecycleEvents } from "@phreshos/core";

package/dist/messagepack.d.ts

@@ -0,0 +1,3 @@
+export type Bytes = Uint8Array<ArrayBuffer>;
+export declare const serialize: (value: unknown, attachments?: readonly object[]) => Bytes;
+export declare const deserialize: (bytes: Uint8Array, attachments?: readonly unknown[]) => unknown;

package/dist/messagepack.js

@@ -0,0 +1,130 @@
+import { decode, encode, ExtensionCodec } from "@msgpack/msgpack";
+class Attachment {
+    index;
+    constructor(index) {
+        this.index = index;
+    }
+}
+class BigInteger {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+class Undefined {
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+const extensions = new ExtensionCodec();
+const serializePrepared = (value, context) => encode(value, { context, extensionCodec: extensions });
+const deserializePrepared = (bytes, context) => decode(bytes, { context, extensionCodec: extensions });
+extensions.register({
+    type: 0,
+    encode: value => value instanceof Attachment ? uint32(value.index) : null,
+    decode: (bytes, _type, context) => {
+        const attachment = context.incoming?.[readUint32(bytes)];
+        if (attachment === undefined)
+            throw new Error("The MessagePack attachment is absent");
+        return attachment;
+    }
+});
+extensions.register({
+    type: 1,
+    encode: (value, context) => value instanceof Map ? serializePrepared([...value], context) : null,
+    decode: (bytes, _type, context) => new Map(deserializePrepared(bytes, context))
+});
+extensions.register({
+    type: 2,
+    encode: (value, context) => value instanceof Set ? serializePrepared([...value], context) : null,
+    decode: (bytes, _type, context) => new Set(deserializePrepared(bytes, context))
+});
+extensions.register({
+    type: 3,
+    encode: (value, context) => value instanceof RegExp ? serializePrepared([value.source, value.flags, value.lastIndex], context) : null,
+    decode: (bytes, _type, context) => {
+        const [source, flags, lastIndex] = deserializePrepared(bytes, context);
+        const expression = new RegExp(source, flags);
+        expression.lastIndex = lastIndex;
+        return expression;
+    }
+});
+extensions.register({
+    type: 4,
+    encode: value => value instanceof URL ? textEncoder.encode(value.href) : null,
+    decode: bytes => new URL(textDecoder.decode(bytes))
+});
+extensions.register({
+    type: 5,
+    encode: (value, context) => value instanceof Error ? serializePrepared(prepare({
+        cause: value.cause,
+        message: value.message,
+        name: value.name,
+        stack: value.stack
+    }, context), context) : null,
+    decode: (bytes, _type, context) => {
+        const value = deserializePrepared(bytes, context);
+        const error = new Error(value.message, { cause: value.cause });
+        error.name = value.name;
+        if (value.stack !== undefined)
+            error.stack = value.stack;
+        return error;
+    }
+});
+extensions.register({
+    type: 6,
+    encode: value => value instanceof BigInteger ? textEncoder.encode(value.value.toString()) : null,
+    decode: bytes => BigInt(textDecoder.decode(bytes))
+});
+extensions.register({
+    type: 7,
+    encode: value => value instanceof Undefined ? new Uint8Array() : null,
+    decode: () => undefined
+});
+export const serialize = (value, attachments = []) => {
+    const outgoing = new Map(attachments.map((attachment, index) => [attachment, index]));
+    const context = { outgoing };
+    return serializePrepared(prepare(value, context), context);
+};
+export const deserialize = (bytes, attachments = []) => {
+    return deserializePrepared(bytes, { incoming: attachments });
+};
+const prepare = (value, context) => {
+    if (value === undefined)
+        return new Undefined();
+    if (typeof value === "bigint")
+        return new BigInteger(value);
+    if (typeof value === "function" || typeof value === "symbol")
+        return null;
+    if (value === null || typeof value !== "object")
+        return value;
+    const attachment = context.outgoing?.get(value);
+    if (attachment !== undefined)
+        return new Attachment(attachment);
+    if (value instanceof Date || value instanceof RegExp || value instanceof URL || value instanceof Error)
+        return value;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (ArrayBuffer.isView(value))
+        return Uint8Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+    if (value instanceof Map)
+        return new Map([...value].map(([key, entry]) => [prepare(key, context), prepare(entry, context)]));
+    if (value instanceof Set)
+        return new Set([...value].map(entry => prepare(entry, context)));
+    if (Array.isArray(value))
+        return value.map(entry => prepare(entry, context));
+    if ("toJSON" in value && typeof value.toJSON === "function")
+        return prepare(value.toJSON(), context);
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, entry]) => typeof entry !== "function")
+        .map(([key, entry]) => [key, prepare(entry, context)]));
+};
+const uint32 = (value) => {
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setUint32(0, value);
+    return bytes;
+};
+const readUint32 = (bytes) => {
+    if (bytes.byteLength !== 4)
+        throw new Error("The MessagePack attachment reference is invalid");
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0);
+};

package/dist/wire.d.ts

@@ -25,6 +25,7 @@ declare class Wire {
         reference: string;
     }>;
     private question;
+    private post;
     expectWithin(question: string, deadline: Deadline): Promise<unknown>;
     forget(question: string): void;
     on(route: string, event: string, handler: Handler, subject?: string | null, impossible?: Failure): Cleanup;

package/dist/wire.js

@@ -1,6 +1,7 @@
 import Deadline from "./deadline.js";
 import { defaultTimeout } from "./events.js";
 import captureClientOutput from "./log.js";
+import { deserialize, serialize } from "./messagepack.js";
 /** The client endpoint's sole postMessage adapter. */
 class Wire {
     parent = window.parent === window ? null : window.parent;
@@ -14,7 +15,19 @@ class Wire {
         window.addEventListener("message", event => {
             if (event.source !== this.parent || !Array.isArray(event.data))
                 return;
-            const [route, ...values] = event.data;
+            const [bytes, ...attachments] = event.data;
+            if (!(bytes instanceof Uint8Array))
+                return;
+            let message;
+            try {
+                message = deserialize(bytes, attachments);
+            }
+            catch {
+                return;
+            }
+            if (!Array.isArray(message) || typeof message[0] !== "string")
+                return;
+            const [route, ...values] = message;
             if (route === "boundary") {
                 const [operation, ...rest] = values;
                 if (operation === "impossible" && typeof rest[0] === "string" && typeof rest[1] === "string") {
@@ -31,7 +44,7 @@ class Wire {
         });
     }
     send(route, ...values) {
-        this.parent?.postMessage([route, ...values], "*");
+        this.post([route, ...values]);
     }
     request(values, timeout = defaultTimeout, transfer = []) {
         return this.question("end-host", values, timeout, transfer);
@@ -108,7 +121,7 @@ class Wire {
                     ? [route, "wait", question, publicId, ...values]
                     : [route, "wait", question, ...values];
                 try {
-                    this.parent?.postMessage(message, "*", transfer);
+                    this.post(message, transfer);
                 }
                 catch (error) {
                     this.pending.delete(question);
@@ -126,6 +139,13 @@ class Wire {
             });
         });
     }
+    post(message, transfer = []) {
+        if (!this.parent)
+            return;
+        const attachments = nativeAttachments(message, transfer);
+        const bytes = serialize(message, attachments);
+        this.parent.postMessage([bytes, ...attachments], "*", [bytes.buffer, ...transfer]);
+    }
     expectWithin(question, deadline) {
         this.send("boundary", "expect", question);
         return new Promise((resolve, reject) => {
@@ -254,6 +274,37 @@ function once(cleanup) {
         cleanup();
     };
 }
+function nativeAttachments(value, transfer) {
+    const attachments = [...transfer];
+    const known = new Set(attachments);
+    const visit = (entry) => {
+        if (entry === null || typeof entry !== "object" || known.has(entry))
+            return;
+        known.add(entry);
+        if (entry instanceof Blob) {
+            attachments.push(entry);
+            return;
+        }
+        if (entry instanceof Date || entry instanceof RegExp || entry instanceof URL || entry instanceof Error || entry instanceof ArrayBuffer || ArrayBuffer.isView(entry))
+            return;
+        if (entry instanceof Map) {
+            for (const [key, item] of entry) {
+                visit(key);
+                visit(item);
+            }
+            return;
+        }
+        if (entry instanceof Set) {
+            for (const item of entry)
+                visit(item);
+            return;
+        }
+        for (const item of Array.isArray(entry) ? entry : Object.values(entry))
+            visit(item);
+    };
+    visit(value);
+    return attachments;
+}
 const wire = new Wire();
 captureClientOutput(wire);
 export default wire;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/client",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "The SDK used by a Program's client endpoint.",
   "type": "module",
   "main": "dist/main.js",
@@ -48,6 +48,9 @@
   "peerDependencies": {
     "@phreshos/core": "^0.1.6"
   },
+  "dependencies": {
+    "@msgpack/msgpack": "^3.1.3"
+  },
   "devDependencies": {
     "@phreshos/core": "^0.1.6",
     "typescript": "^6.0.3"