libshv-js 3.4.2 → 3.6.0

package/.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
     name: CPON/Chainpack conversions
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Install dependencies
         run: npm install
@@ -25,4 +25,6 @@ jobs:
         run: npx tsc
 
       - name: Run tests
-        run: node test.js
+        run: |
+          node test.js
+          node test_json.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libshv-js",
-  "version": "3.4.2",
+  "version": "3.6.0",
   "description": "Typescript implementation of libshv",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -21,6 +21,7 @@
     "./chainpack.ts": "./src/chainpack.ts",
     "./cpcontext.ts": "./src/cpcontext.ts",
     "./cpon.ts": "./src/cpon.ts",
+    "./json.ts": "./src/json.ts",
     "./rpcmessage.ts": "./src/rpcmessage.ts",
     "./rpcvalue.ts": "./src/rpcvalue.ts",
     "./ws-client.ts": "./src/ws-client.ts",

package/src/cpon.ts

@@ -2,6 +2,33 @@
 import {type RpcValue, type RpcValueType, type DateTime, type List, Decimal, Double, type IMap, type Int, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, shvMapType, isShvMap, isIMap} from './rpcvalue';
 import {PackContext, UnpackContext} from './cpcontext';
 
+export const stringifyDate = (dt: DateTime) => {
+    const epochMsec = dt.getTime();
+    let utcOffset = dt.utc_offset;
+    const localMsec = epochMsec + (60_000 * (utcOffset ?? 0));
+    let res = new Date(localMsec).toISOString();
+    const rtrim = (localMsec % 1000) ? 1 : 5;
+    res = res.slice(0, Math.max(0, res.length - rtrim));
+
+    if (utcOffset === undefined || utcOffset === 0) {
+        res += 'Z';
+    } else {
+        if (utcOffset < 0) {
+            res += '-';
+            utcOffset = -utcOffset;
+        } else {
+            res += '+';
+        }
+
+        res += (Math.trunc(utcOffset / 60)).toString().padStart(2, '0');
+        if (utcOffset % 60) {
+            res += (utcOffset % 60).toString().padStart(2, '0');
+        }
+    }
+
+    return res;
+};
+
 const hexify = (byte: number) => {
     if (byte < 10) {
         return 48 + byte;
@@ -222,6 +249,25 @@ class CponReader {
     }
 
     readDateTime() {
+        this.ctx.getByte(); // eat '"'
+        let b = this.ctx.peekByte();
+        if (b === '"'.codePointAt(0)) {
+            // d"" invalid data time
+            this.ctx.getByte();
+            throw new TypeError('Malformed empty date separator in DateTime');
+        }
+
+        const date = this.readDateTimeInner();
+
+        b = this.ctx.getByte();
+        if (b !== '"'.codePointAt(0)) {
+            throw new TypeError('DateTime literal should be terminated by \'"\'.');
+        }
+
+        return date;
+    }
+
+    readDateTimeInner() {
         let year = 0;
         let month = 0;
         let day = 1;
@@ -231,17 +277,9 @@ class CponReader {
         let msec = 0;
         let utcOffset = 0;
 
-        this.ctx.getByte(); // eat '"'
-        let b = this.ctx.peekByte();
-        if (b === '"'.codePointAt(0)) {
-            // d"" invalid data time
-            this.ctx.getByte();
-            throw new TypeError('Malformed empty date separator in DateTime');
-        }
-
         year = Number(this.readInt());
 
-        b = this.ctx.getByte();
+        let b = this.ctx.getByte();
         if (b !== '-'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
@@ -307,11 +345,6 @@ class CponReader {
             }
         }
 
-        b = this.ctx.getByte();
-        if (b !== '"'.codePointAt(0)) {
-            throw new TypeError('DateTime literal should be terminated by \'"\'.');
-        }
-
         // let epoch_sec = CponReader.timegm(year, month, mday, hour, min, sec);
         let epochMsec = Date.UTC(year, month - 1, day, hour, min, sec, msec);
         epochMsec -= utcOffset * 60_000;
@@ -775,41 +808,8 @@ class CponWriter {
     }
 
     writeDateTime(dt: DateTime) {
-        if (!dt) {
-            this.ctx.writeStringUtf8('d""');
-            return;
-        }
-
-        const epochMsec = dt.getTime();
-        let utcOffset = dt.utc_offset;
-        const localMsec = epochMsec + (60_000 * (utcOffset ?? 0));
-        let s = new Date(localMsec).toISOString();
-        const rtrim = (localMsec % 1000) ? 1 : 5;
         this.ctx.writeStringUtf8('d"');
-        for (let i = 0; i < s.length - rtrim; i++) {
-            this.ctx.putByte(s.codePointAt(i)!);
-        }
-
-        if (utcOffset === undefined || utcOffset === 0) {
-            this.ctx.writeStringUtf8('Z');
-        } else {
-            if (utcOffset < 0) {
-                this.ctx.writeStringUtf8('-');
-                utcOffset = -utcOffset;
-            } else {
-                this.ctx.writeStringUtf8('+');
-            }
-
-            s = (Math.trunc(utcOffset / 60)).toString().padStart(2, '0');
-            if (utcOffset % 60) {
-                s += (utcOffset % 60).toString().padStart(2, '0');
-            }
-
-            for (let i = 0; i < s.length; i++) {
-                this.ctx.putByte(s.codePointAt(i)!);
-            }
-        }
-
+        this.ctx.writeStringUtf8(stringifyDate(dt));
         this.ctx.writeStringUtf8('"');
     }
 
@@ -835,10 +835,6 @@ class CponWriter {
         this.doIndentIfNotOneliner(map);
         let first = true;
         for (const [key, value] of Object.entries<RpcValue>(map)) {
-            if (value === undefined) {
-                continue;
-            }
-
             if (!first) {
                 this.ctx.putByte(','.codePointAt(0)!);
                 this.doIndentIfNotOneliner(map);

package/src/json.ts

@@ -0,0 +1,136 @@
+import {UnpackContext} from './cpcontext';
+import {CponReader, stringifyDate} from './cpon';
+import {Decimal, Double, isIMap, isShvMap, makeIMap, makeMap, makeMetaMap, RpcValueWithMetaData, UInt, type RpcValue} from './rpcvalue';
+
+// eslint-disable-next-line @typescript-eslint/ban-types -- Zod needs the default argument, otherwise it'll infer as UInt<unknown>
+const decodeMap = (x: object) => makeMap(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, decodeValueJson(value)])));
+
+const decodeValueJson = (x: unknown): RpcValue => {
+    switch (true) {
+        case Array.isArray(x): {
+            const list = x as unknown[];
+            const handleType = (typeName: unknown, typeValue: unknown) => {
+                switch (true) {
+                    case typeName === 'Blob': {
+                        if (typeof typeValue !== 'string' || typeValue.length % 2 !== 0) {
+                            throw new TypeError(`Invalid JSON-encoded Blob: '${JSON.stringify(typeValue)}'`);
+                        }
+
+                        const buffer = new ArrayBuffer(typeValue.length / 2);
+                        const array = new Uint8Array(buffer);
+
+                        // I can assume even length because of the previous check.
+                        for (let i = 0; i < typeValue.length / 2; i++) {
+                            array[i] = Number.parseInt(typeValue.slice(i * 2, (i * 2) + 2), 16);
+                        }
+
+                        return buffer;
+                    }
+
+                    case typeName === 'IMap':
+                        if (typeof typeValue !== 'object' || typeValue === null) {
+                            throw new TypeError(`Invalid JSON-encoded IMap: '${JSON.stringify(typeValue)}'`);
+                        }
+
+                        if (Object.keys(typeValue).some(key => !/^-?\d+$/.test(key))) {
+                            throw new TypeError(`Invalid JSON-encoded IMap (non-Int key): '${JSON.stringify(typeValue)}'`);
+                        }
+
+                        return makeIMap(decodeMap(typeValue));
+                    case typeName === 'DateTime':
+                        if (typeof typeValue !== 'string') {
+                            throw new TypeError(`Invalid JSON-encoded DateTime: '${JSON.stringify(typeValue)}'`);
+                        }
+
+                        // Kinda lame that I'm encoding the datetime string, but this is the easiest way right now.
+                        return new CponReader(new UnpackContext(new TextEncoder().encode(typeValue).buffer)).readDateTimeInner();
+                    default:
+                        throw new TypeError(`Invalid JSON-encoded type name: '${JSON.stringify(typeName)}'`);
+                }
+            };
+
+            switch (true) {
+                case list.length === 3 && list[0] === JSON_TAG_TYPE:
+                    return handleType(list[1], list[2]);
+                case list.length === 3 && list[0] === JSON_TAG_META:
+                case list.length === 5 && list[0] === JSON_TAG_META && list[2] === JSON_TAG_TYPE: {
+                    if (typeof list[1] !== 'object' || list[1] === null) {
+                        throw new TypeError(`Invalid JSON-encoded MetaData: '${JSON.stringify(list[1])}'`);
+                    }
+
+                    const value = (() => {
+                        if (list.length === 3) {
+                            const decoded = decodeValueJson(list[2]);
+                            if (decoded instanceof RpcValueWithMetaData) {
+                                throw new TypeError('Logic error: got RpcValueWithMetaData as the value in JSON-encoded RpcValueWithMetaData, please report this bug to the maintainer.');
+                            }
+
+                            return decoded;
+                        }
+
+                        return handleType(list[3], list[4]);
+                    })();
+
+                    return new RpcValueWithMetaData(makeMetaMap(decodeMap(list[1])), value);
+                }
+
+                default:
+                    return list.map(value => decodeValueJson(value));
+            }
+        }
+
+        case x === null:
+            return undefined;
+        case typeof x === 'object':
+            return decodeMap(x);
+        case typeof x === 'number':
+        case typeof x === 'boolean':
+        case typeof x === 'string':
+            return x;
+        default:
+            throw new Error(`Unknown JSON-encoded value: ${JSON.stringify(x)}`);
+    }
+};
+
+export const fromJson = (str: string): RpcValue | Error => decodeValueJson(JSON.parse(str));
+
+const JSON_TAG_META = '!shvMeta';
+const JSON_TAG_TYPE = '!shvType';
+
+const encodeValueJson = (x: RpcValue): unknown => {
+    switch (true) {
+        case x instanceof RpcValueWithMetaData: {
+            const res = [JSON_TAG_META, encodeValueJson(makeMap(x.meta))] as const;
+            const encoded = encodeValueJson(x.value);
+            if (Array.isArray(encoded) && encoded[0] === JSON_TAG_TYPE) {
+                return [...res, ...encoded as unknown[]];
+            }
+
+            return [...res, encoded];
+        }
+
+        case Array.isArray(x):
+            return x.map(value => encodeValueJson(value));
+        case isShvMap(x): {
+            const map = x as Record<string, RpcValue>;
+            return Object.fromEntries(Object.entries(map).map(([key, value]) => [key, encodeValueJson(value)] as const));
+        }
+
+        case isIMap(x):
+            return [JSON_TAG_TYPE, 'IMap', encodeValueJson(makeMap(x))];
+        case x instanceof ArrayBuffer:
+            return [JSON_TAG_TYPE, 'Blob', new Uint8Array(x).reduce((acc, v) => acc + v.toString(16).padStart(2, '0'), '')];
+        case x instanceof Date:
+            return [JSON_TAG_TYPE, 'DateTime', stringifyDate(x)];
+        case x === undefined:
+            return null;
+        case x instanceof Decimal:
+        case x instanceof UInt:
+        case x instanceof Double:
+            throw new TypeError('Decimal/Double/UInt not supported in JSON');
+        default:
+            return x;
+    }
+};
+
+export const toJson = (value: RpcValue): string | Error => JSON.stringify(encodeValueJson(value));

package/src/ws-client.ts

@@ -36,21 +36,38 @@ type Subscription = {
     callback: SubscriptionCallback;
 };
 
-type WsClientOptions = {
+type Login = {
+    type: 'PLAIN';
+    user: string;
+    password: string;
+} | {
+    type: 'TOKEN';
+    token: string;
+};
+
+type WsClientOptionsCommon = {
     logDebug: (...args: string[]) => void;
+    wsUri: string;
+};
+
+type WsClientOptionsLogin = WsClientOptionsCommon & {
     mountPoint?: string;
-    user?: string;
-    password: string;
-    loginType?: 'PLAIN' | 'AZURE';
+    login: Login;
     timeout?: number;
     pingInterval?: number;
-    wsUri: string;
     onConnected: () => void;
     onConnectionFailure: (error: Error) => void;
     onDisconnected: () => void;
     onRequest: (rpc_msg: RpcRequest) => void;
 };
 
+type WsClientOptionsWorkflows = WsClientOptionsCommon & {
+    onWorkflows: (workflows: RpcValue) => void;
+    onWorkflowsFailed: () => void;
+};
+
+type WsClientOptions = WsClientOptionsLogin | WsClientOptionsWorkflows;
+
 type LsResult = string[];
 export enum DirFlags {
     Reserved = 1,
@@ -103,99 +120,31 @@ class UserIDRequired extends RpcError {}
 class NotImplemented extends RpcError {}
 
 class WsClient {
-    requestId = 1;
-    pingTimerId = -1;
+    private requestId = 1;
+    private pingTimerId = -1;
 
-    rpcHandlers: Array<{
+    private rpcHandlers: Array<{
         resolve: RpcResponseResolver;
         timeout_handle: number;
     }> = [];
 
-    subscriptions: Subscription[] = [];
-    websocket: WebSocket;
-
-    logDebug: WsClientOptions['logDebug'];
-    mountPoint: WsClientOptions['mountPoint'];
-    user?: WsClientOptions['user'];
-    password: WsClientOptions['password'];
-    loginType: WsClientOptions['loginType'];
-    onConnected: WsClientOptions['onConnected'];
-    onConnectionFailure: WsClientOptions['onConnectionFailure'];
-    onDisconnected: WsClientOptions['onDisconnected'];
-    onRequest: WsClientOptions['onRequest'];
-    timeout: WsClientOptions['timeout'];
-    pingInterval: WsClientOptions['pingInterval'];
+    private readonly subscriptions: Subscription[] = [];
+    private readonly websocket: WebSocket;
+
+    private readonly options: WsClientOptions;
+    private readonly timeout: number;
 
     constructor(options: WsClientOptions) {
         if (typeof options !== 'object') {
             throw new TypeError('No options object supplied');
         }
 
-        this.logDebug = options.logDebug ?? (() => {/* nothing */});
-        this.mountPoint = options.mountPoint;
-
-        this.user = options.user ?? '';
-        this.password = options.password;
-        this.loginType = options.loginType ?? 'PLAIN';
+        this.options = options;
+        this.timeout = 'timeout' in options && options.timeout !== undefined ? options.timeout : DEFAULT_TIMEOUT;
 
         this.websocket = new WebSocket(options.wsUri);
         this.websocket.binaryType = 'arraybuffer';
 
-        this.pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
-        this.onConnected = options.onConnected ?? (() => {/* nothing */});
-        this.onConnectionFailure = options.onConnectionFailure ?? (() => {/* nothing */});
-        this.onDisconnected = options.onDisconnected ?? (() => {/* nothing */});
-        this.onRequest = options.onRequest ?? (() => {/* nothing */});
-
-        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
-
-        this.websocket.addEventListener('open', () => {
-            this.logDebug('CONNECTED');
-            const handleConnectionError = (error: Error) => {
-                this.logDebug('FAILURE: couldn\'t perform initial handshake', error.message);
-                this.onConnectionFailure(error);
-            };
-
-            this.callRpcMethod(undefined, 'hello').then(response => {
-                if (response instanceof Error) {
-                    handleConnectionError(response);
-                    return;
-                }
-
-                const params = makeMap({
-                    login: makeMap({
-                        password: this.password,
-                        type: this.loginType,
-                        user: this.user,
-                    }),
-                    options: makeMap({
-                        device: this.mountPoint === 'string' ? makeMap({mountPoint: this.mountPoint}) : undefined,
-                    }),
-                });
-                return this.callRpcMethod(undefined, 'login', params);
-            }).then(response => {
-                if (response instanceof Error) {
-                    handleConnectionError(response);
-                    return;
-                }
-
-                this.logDebug('SUCCESS: connected to shv broker');
-                this.onConnected();
-                this.pingTimerId = window.setInterval(() => {
-                    this.sendPing();
-                }, this.pingInterval);
-            }).catch(() => {
-                this.logDebug('FAILURE: couldn\' connected to shv broker');
-            });
-        });
-
-        this.websocket.addEventListener('close', () => {
-            this.logDebug('DISCONNECTED');
-            this.subscriptions.length = 0;
-            this.onDisconnected();
-            window.clearInterval(this.pingTimerId);
-        });
-
         this.websocket.addEventListener('message', (evt: MessageEvent<ArrayBuffer>) => {
             const rpcVal = dataToRpcValue(evt.data);
             const rpcMsg = RpcMessageZod.parse(rpcVal);
@@ -211,7 +160,9 @@ class WsClient {
                     }
                 }
             } else if (isRequest(rpcMsg)) {
-                this.onRequest(rpcMsg);
+                if ('onRequest' in this.options) {
+                    this.options.onRequest(rpcMsg);
+                }
             } else if (isResponse(rpcMsg)) {
                 const requestId = rpcMsg.meta[RPC_MESSAGE_REQUEST_ID];
 
@@ -258,6 +209,12 @@ class WsClient {
             console.log('WebSocket ERROR', evt);
             this.logDebug('WebSocket ERROR');
         });
+
+        if ('onWorkflows' in this.options) {
+            this.workflowsProcedure(this.options);
+        } else {
+            this.loginProcedure(this.options);
+        }
     }
 
     callRpcMethod(shv_path: '.broker/currentClient', method: 'accessGrantForMethodCall', params: [string, string]): Promise<ResultOrError<string>>;
@@ -272,8 +229,7 @@ class WsClient {
             [RPC_MESSAGE_SHV_PATH]: shv_path ?? '',
         }), makeIMap({
             [RPC_MESSAGE_PARAMS]: params,
-        }),
-        );
+        }));
 
         this.sendRpcMessage(rq);
 
@@ -370,6 +326,110 @@ class WsClient {
     close() {
         this.websocket.close();
     }
+
+    private logDebug(...args: string[]) {
+        if (this.options.logDebug === undefined) {
+            return;
+        }
+
+        this.options.logDebug(...args);
+    }
+
+    private workflowsProcedure(options: WsClientOptionsWorkflows) {
+        let workflowsObtained = false;
+        this.websocket.addEventListener('open', () => {
+            this.options.logDebug('CONNECTED');
+            const handleConnectionError = (error: Error) => {
+                this.logDebug('FAILURE: couldn\'t retrieve workflows', error.message);
+                options.onWorkflowsFailed();
+            };
+
+            this.callRpcMethod(undefined, 'workflows').then(response => {
+                if (response instanceof Error) {
+                    handleConnectionError(response);
+                    return;
+                }
+
+                workflowsObtained = true;
+                options.onWorkflows(response);
+
+                this.close();
+            }).catch((_: unknown) => {
+                options.onWorkflowsFailed();
+            });
+        });
+
+        this.websocket.addEventListener('close', () => {
+            this.logDebug('DISCONNECTED');
+            if (!workflowsObtained) {
+                options.onWorkflowsFailed();
+            }
+        });
+    }
+
+    private loginProcedure(options: WsClientOptionsLogin) {
+        this.websocket.addEventListener('open', () => {
+            this.options.logDebug('CONNECTED');
+            const handleConnectionError = (error: Error) => {
+                this.logDebug('FAILURE: couldn\'t perform initial handshake', error.message);
+                options.onConnectionFailure(error);
+            };
+
+            const handleLoginResponse = (response: any) => {
+                if (response instanceof Error) {
+                    handleConnectionError(response);
+                    return;
+                }
+
+                this.logDebug('SUCCESS: connected to shv broker');
+                options.onConnected();
+                this.pingTimerId = window.setInterval(() => {
+                    this.sendPing();
+                }, options.pingInterval ?? DEFAULT_PING_INTERVAL);
+            };
+
+            const makeLoginParams = (loginMap: ShvMap) => makeMap({
+                login: loginMap,
+                options: makeMap({
+                    device: options.mountPoint === 'string' ? makeMap({mountPoint: options.mountPoint}) : undefined,
+                }),
+            });
+
+            this.callRpcMethod(undefined, 'hello').then(response => {
+                if (response instanceof Error) {
+                    handleConnectionError(response);
+                    return;
+                }
+
+                const makeLoginMap = () => {
+                    switch (options.login.type) {
+                        case 'PLAIN':
+                            return makeMap({
+                                password: options.login.password,
+                                type: options.login.type,
+                                user: options.login.user,
+                            });
+                        case 'TOKEN':
+                            return makeMap({
+                                token: options.login.token,
+                                type: options.login.type,
+                            });
+                    }
+                };
+
+                return this.callRpcMethod(undefined, 'login', makeLoginParams(makeLoginMap()));
+            }).then(handleLoginResponse).catch(() => {
+                this.logDebug('FAILURE: couldn\' connected to shv broker');
+            });
+        });
+
+        this.websocket.addEventListener('close', () => {
+            this.logDebug('DISCONNECTED');
+            this.subscriptions.length = 0;
+            options.onDisconnected();
+            window.clearInterval(this.pingTimerId);
+        });
+    }
 }
 
 export {WsClient};

package/src/zod.ts

@@ -11,9 +11,10 @@ export const uint = () => z.instanceof(UInt<number>);
 export const double = () => z.instanceof(Double);
 export const decimal = () => z.instanceof(Decimal);
 export const blob = () => z.instanceof(ArrayBuffer);
+export const list = () => z.array(z.lazy(rpcvalue));
 
 const withMetaInstanceParser = z.instanceof(RpcValueWithMetaData);
-export const rpcvalue = () => z.union([
+export const rpcvalue: () => ZodType<RpcValue, any, any> = () => z.union([
     z.undefined(),
     z.boolean(),
     z.number(),
@@ -23,7 +24,7 @@ export const rpcvalue = () => z.union([
     blob(),
     z.string(),
     z.date(),
-    z.array(z.any()),
+    list(),
     map(),
     imap(),
     withMetaInstanceParser,

package/test_json.ts

@@ -0,0 +1,44 @@
+import { toCpon } from "./src/cpon";
+import { fromJson, toJson } from "./src/json";
+import {makeIMap, makeMap, makeMetaMap, RpcValue, RpcValueWithMetaData, withOffset} from "./src/rpcvalue";
+
+const testJsonRoundTrip = (json: string, expected: RpcValue) => {
+	const parsed = fromJson(json);
+	if (parsed instanceof Error) {
+		throw parsed;
+	}
+	const parsedCpon = toCpon(parsed);
+	const expectedCpon = toCpon(expected);
+	if (parsedCpon !== expectedCpon) {
+		throw new Error(`Assertion error:\nExpected: '${expectedCpon}'\nActual: '${parsedCpon}'`);
+	}
+
+	const serializedJson = toJson(expected);
+	if (serializedJson !== json.replaceAll(' ', '')) {
+		throw new Error(`Assertion error:\nExpected: '${json}'\nActual: '${serializedJson}'`);
+	}
+
+};
+
+const MINUTE = 1;
+const HOUR = 60 * MINUTE;
+
+const tests = [
+	['{}', makeMap({})],
+	['{"null-field": null}', makeMap({"null-field": undefined})],
+	['["!shvType", "Blob", ""]', new Uint8Array().buffer],
+	['["!shvType", "Blob", "6162a1"]', new Uint8Array([0x61, 0x62, 0xa1]).buffer],
+	['["!shvType", "IMap", {}]', makeIMap({})],
+	['["!shvType", "IMap", {"1": 2}]', makeIMap({1: 2})],
+	['["!shvType", "IMap", {"1": 2, "2": "foo"}]', makeIMap({1: 2, 2: "foo"})],
+	['["!shvType", "DateTime", "2021-11-08T01:02:03+05"]', withOffset(new Date("2021-11-08T01:02:03+05:00"), 5 * HOUR)],
+	['["!shvType", "DateTime", "2021-11-08T01:02:03-0815"]', withOffset(new Date("2021-11-08T01:02:03-08:15"), -8 * HOUR - 15 * MINUTE)],
+	['["!shvType", "DateTime", "2021-11-08T01:02:03.456-0815"]', withOffset(new Date("2021-11-08T01:02:03.456-08:15"), -8 * HOUR - 15 * MINUTE)],
+	['["!shvMeta", {"1":2}, 42]', new RpcValueWithMetaData(makeMetaMap({1: 2}), 42)],
+	['["!shvMeta", {"1":2}, "!shvType", "IMap", {"42": 7}]', new RpcValueWithMetaData(makeMetaMap({1: 2}), makeIMap({42: 7}))],
+	['["!shvMeta", {"1": 2, "foo": "bar"}, [1,2,3]]', new RpcValueWithMetaData(makeMetaMap({1: 2, "foo": "bar"}), [1, 2, 3])],
+] as const;
+
+tests.forEach(([inputJson, expectedRpcValue]) => testJsonRoundTrip(inputJson, expectedRpcValue));
+
+console.log('OK');