@phreshos/server 0.1.6 → 0.1.7

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.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import Deadline from "./deadline.js";
 import { defaultTimeout } from "./events.js";
+import { deserialize, serialize } from "./messagepack.js";
 /** The server endpoint's sole IPC adapter. */
 class Wire {
     pending = new Map();
@@ -12,9 +13,18 @@ class Wire {
     identityPromise = null;
     constructor() {
         process.on("message", message => {
-            if (!Array.isArray(message))
+            if (!(message instanceof Uint8Array))
                 return;
-            const [route, ...values] = message;
+            let decoded;
+            try {
+                decoded = deserialize(message);
+            }
+            catch {
+                return;
+            }
+            if (!Array.isArray(decoded) || typeof decoded[0] !== "string")
+                return;
+            const [route, ...values] = decoded;
             if (route === "boundary") {
                 const [operation, ...rest] = values;
                 if (operation === "forget" && typeof rest[0] === "string")
@@ -35,10 +45,10 @@ class Wire {
             }
             this.deliver(route, values);
         });
-        process.send?.(["boundary", "ready"]);
+        process.send?.(serialize(["boundary", "ready"]));
     }
     send(route, ...values) {
-        process.send?.([route, ...values]);
+        process.send?.(serialize([route, ...values]));
     }
     request(values, timeout = defaultTimeout) {
         return this.requestWithin(values, new Deadline(timeout));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/server",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "The SDK used by a Program's server 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",
     "@types/node": "^26.2.0",