pelican-engine 0.0.0-stage → 0.3.1

package/lib/protocol/index.js

@@ -0,0 +1,92 @@
+/** Shared transport schemas. No browser automation or GPU objects leak through this boundary. */
+export const PROTOCOL_VERSION = "0.1.0";
+export function result(taskId, status, data, diagnostics = [], artifacts = []) {
+    return {
+        protocolVersion: PROTOCOL_VERSION,
+        taskId,
+        status,
+        diagnostics,
+        artifacts,
+        data,
+    };
+}
+export function parseCommand(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("TC_PROTOCOL_COMMAND: Expected an object.");
+    const v = value;
+    if (typeof v.type !== "string")
+        throw new Error("TC_PROTOCOL_COMMAND: Missing command type.");
+    const requireKeys = (keys) => {
+        for (const key of Object.keys(v))
+            if (!["type", ...keys].includes(key))
+                throw new Error(`TC_PROTOCOL_FIELD: Unknown command field ${key}.`);
+    };
+    switch (v.type) {
+        case "inspect":
+            requireKeys(["entity", "offset", "limit"]);
+            if (v.entity !== undefined &&
+                (typeof v.entity !== "string" ||
+                    !v.entity.length ||
+                    v.entity.length > 256))
+                throw new Error("TC_PROTOCOL_ENTITY: Invalid entity id.");
+            if (v.offset !== undefined &&
+                (!Number.isSafeInteger(v.offset) || Number(v.offset) < 0))
+                throw new Error("TC_PROTOCOL_PAGE: Invalid offset.");
+            if (v.limit !== undefined &&
+                (!Number.isInteger(v.limit) ||
+                    Number(v.limit) < 1 ||
+                    Number(v.limit) > 1000))
+                throw new Error("TC_PROTOCOL_PAGE: limit must be in [1,1000].");
+            break;
+        case "pause":
+        case "resume":
+        case "snapshot":
+        case "capture":
+        case "recordStart":
+        case "recordStop":
+        case "recordCancel":
+            requireKeys([]);
+            break;
+        case "replay":
+            requireKeys(["trace"]);
+            if (!v.trace || typeof v.trace !== "object")
+                throw new Error("TC_PROTOCOL_TRACE: trace is required.");
+            break;
+        case "step":
+            requireKeys(["count"]);
+            if (!Number.isInteger(v.count) ||
+                Number(v.count) < 1 ||
+                Number(v.count) > 10000)
+                throw new Error("TC_PROTOCOL_STEPS: count must be an integer in [1,10000].");
+            break;
+        case "restore":
+            requireKeys(["snapshot"]);
+            if (!v.snapshot || typeof v.snapshot !== "object")
+                throw new Error("TC_PROTOCOL_SNAPSHOT: snapshot is required.");
+            break;
+        case "input":
+            requireKeys(["key", "pressed"]);
+            if (typeof v.key !== "string" ||
+                v.key.length > 64 ||
+                typeof v.pressed !== "boolean")
+                throw new Error("TC_PROTOCOL_INPUT: Expected key and pressed.");
+            break;
+        case "setComponent":
+            requireKeys(["entity", "component", "value"]);
+            if (typeof v.entity !== "string" ||
+                typeof v.component !== "string" ||
+                !v.value ||
+                typeof v.value !== "object" ||
+                Array.isArray(v.value))
+                throw new Error("TC_PROTOCOL_COMPONENT: Expected entity, component and value.");
+            break;
+        case "mode":
+            requireKeys(["mode"]);
+            if (!["raster", "hybrid", "path"].includes(String(v.mode)))
+                throw new Error("TC_PROTOCOL_MODE: Unknown render mode.");
+            break;
+        default:
+            throw new Error(`TC_PROTOCOL_COMMAND: Unknown command ${v.type}.`);
+    }
+    return v;
+}