@anweather/game-plugin-ssdk 1.24.0 → 1.26.0

package/dist-es/runtime/conformance.js

@@ -1,5 +1,6 @@
 import { isDeepStrictEqual } from "node:util";
 import { PLUGIN_PROTOCOL_VERSION } from "./version";
+import { validatePresentation } from "./presentation";
 import { runLiveConformance } from "./live/conformance";
 function participantIds(n) {
     return Array.from({ length: n }, (_, i) => `00000000-0000-4000-8000-${String(i + 1).padStart(12, "0")}`);
@@ -30,6 +31,12 @@ export async function runConformance(service, context, options = {}) {
         expect(minPlayers >= 1, `minPlayers ${metadata.minPlayers} < 1`);
         expect(maxPlayers >= minPlayers, `maxPlayers ${metadata.maxPlayers} < minPlayers ${metadata.minPlayers}`);
     });
+    if (metadata.presentation !== undefined) {
+        await check("GetMetadata: presentation is valid", async () => {
+            const problems = validatePresentation(metadata.presentation);
+            expect(problems.length === 0, problems.join("; "));
+        });
+    }
     await check("Health: ok, same gameType as metadata, current protocol version", async () => {
         const health = await service.Health({}, context);
         expect(health.status === "ok", `status is "${health.status}"`);

package/dist-es/runtime/index.js

@@ -3,6 +3,7 @@ export { createGamePluginService } from "./defaultService";
 export { servePlugin, createPluginApp } from "./servePlugin";
 export { createRegistrationLoop } from "./registration";
 export { runConformance, assertConformance } from "./conformance";
+export { validatePresentation, assertPresentation, PRESENTATION_CATEGORIES, MAX_PRESENTATION_BYTES } from "./presentation";
 export { PLUGIN_PROTOCOL_VERSION, runtimeVersion } from "./version";
 export { createBlobClient, casUpdate, blobOwner, allBlobOwners, BlobStoreError, isVersionConflict } from "./blobClient";
 export { attachLive } from "./live/server";

package/dist-es/runtime/presentation.js

@@ -0,0 +1,93 @@
+export const PRESENTATION_CATEGORIES = ["classic", "strategy", "cards", "word", "wip"];
+export const MAX_PRESENTATION_BYTES = 32 * 1024;
+const str = { kind: "string" };
+const bool = { kind: "boolean" };
+const oneOf = (...values) => ({ kind: "oneOf", values });
+const obj = (fields) => ({ kind: "object", fields });
+const SCHEMA = obj({
+    catalogue: obj({
+        title: str,
+        category: oneOf(...PRESENTATION_CATEGORIES),
+        featured: bool,
+        poster: obj({ from: { kind: "token" }, to: { kind: "token" }, text: { kind: "token" } }),
+    }),
+    rules: { kind: "strings" },
+    board: obj({
+        layout: oneOf("fullscreen", "page"),
+        page: obj({ nameplates: oneOf("split", "below", "none"), fullBleed: bool }),
+        moveErrors: oneOf("platform", "board"),
+        nativeGestures: oneOf("suppress", "allow"),
+        recap: { kind: "falseOr", object: obj({ stepMs: { kind: "int", min: 100, max: 10_000 } }) },
+        host: obj({ overflowX: oneOf("auto", "hidden", "clip"), width: oneOf("fit", "full") }),
+    }),
+    rematch: obj({ seatNames: { kind: "strings", size: 2 } }),
+});
+const POSTER_TOKEN = /^([a-z]+-(50|[1-9]00|950)|white|black)$/;
+export function validatePresentation(value) {
+    const problems = [];
+    const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    const visit = (v, rule, path) => {
+        switch (rule.kind) {
+            case "string":
+                if (typeof v !== "string")
+                    problems.push(`${path} is not a string`);
+                return;
+            case "boolean":
+                if (typeof v !== "boolean")
+                    problems.push(`${path} is not a boolean`);
+                return;
+            case "oneOf":
+                if (typeof v !== "string" || !rule.values.includes(v))
+                    problems.push(`${path} is not one of ${rule.values.join(", ")}`);
+                return;
+            case "int":
+                if (!Number.isInteger(v) || v < rule.min || v > rule.max) {
+                    problems.push(`${path} is not an integer in ${rule.min}..${rule.max}`);
+                }
+                return;
+            case "strings":
+                if (!Array.isArray(v) || !v.every((s) => typeof s === "string"))
+                    problems.push(`${path} is not a list of strings`);
+                else if (rule.size !== undefined && v.length !== rule.size)
+                    problems.push(`${path} does not have ${rule.size} entries`);
+                return;
+            case "token":
+                if (typeof v !== "string" || !POSTER_TOKEN.test(v))
+                    problems.push(`${path} is not a palette token like "amber-700"`);
+                return;
+            case "falseOr":
+                if (v === false)
+                    return;
+                if (!isObject(v))
+                    problems.push(`${path} is neither false nor an object`);
+                else
+                    visit(v, rule.object, path);
+                return;
+            case "object":
+                if (!isObject(v)) {
+                    problems.push(`${path} is not an object`);
+                    return;
+                }
+                for (const [key, child] of Object.entries(v)) {
+                    const childRule = rule.fields[key];
+                    if (!childRule)
+                        problems.push(`${path}.${key} is not a known field`);
+                    else if (child !== undefined)
+                        visit(child, childRule, `${path}.${key}`);
+                }
+                return;
+        }
+    };
+    visit(value, SCHEMA, "presentation");
+    if (problems.length === 0) {
+        const bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
+        if (bytes > MAX_PRESENTATION_BYTES)
+            problems.push(`presentation is ${bytes} bytes; the limit is ${MAX_PRESENTATION_BYTES}`);
+    }
+    return problems;
+}
+export function assertPresentation(value) {
+    const problems = validatePresentation(value);
+    if (problems.length > 0)
+        throw new Error(`invalid presentation:\n  ${problems.join("\n  ")}`);
+}

package/dist-es/runtime/servePlugin.js

@@ -5,8 +5,22 @@ import { mountSsdkHandler } from "./express";
 import { createRegistrationLoop } from "./registration";
 import { PLUGIN_PROTOCOL_VERSION, runtimeVersion } from "./version";
 import { attachLive } from "./live/server";
+import { assertPresentation } from "./presentation";
 import { bearerMatches } from "./auth";
 const permissiveValidation = () => undefined;
+function withPresentation(service, presentation) {
+    if (presentation === undefined)
+        return service;
+    return {
+        ...service,
+        GetMetadata: async (input, context) => {
+            const metadata = await service.GetMetadata(input, context);
+            return metadata.presentation === undefined
+                ? { ...metadata, presentation: presentation }
+                : metadata;
+        },
+    };
+}
 export function createPluginApp(options) {
     const env = options.env ?? process.env;
     const port = Number(env.PORT ?? options.defaultPort ?? 0);
@@ -14,6 +28,9 @@ export function createPluginApp(options) {
     const platformUrl = env.PLATFORM_URL || undefined;
     const backendBaseUrl = env.PLUGIN_BACKEND_BASE_URL || `http://localhost:${port}`;
     const log = options.log ?? console;
+    if (options.presentation !== undefined)
+        assertPresentation(options.presentation);
+    const definition = withPresentation(options.service, options.presentation);
     const service = createGamePluginService({
         Health: async () => ({
             status: "ok",
@@ -21,7 +38,7 @@ export function createPluginApp(options) {
             protocolVersion: PLUGIN_PROTOCOL_VERSION,
             runtimeVersion: runtimeVersion(),
         }),
-        ...options.service,
+        ...definition,
     });
     const handler = getGamePluginServiceHandler(service, options.validationCustomizer ?? permissiveValidation);
     const app = express();

package/dist-es/src/models/models_0.js

@@ -595,6 +595,10 @@ export var GameTypeMetadata;
                         memberValidators["live"] = new __CompositeStructureValidator(new __NoOpValidator(), LiveCapability.validate);
                         break;
                     }
+                    case "presentation": {
+                        memberValidators["presentation"] = new __NoOpValidator();
+                        break;
+                    }
                 }
             }
             return memberValidators[member];
@@ -617,6 +621,7 @@ export var GameTypeMetadata;
             ...getMemberValidator("hasSaveFileEditor").validate(obj.hasSaveFileEditor, `${path}/hasSaveFileEditor`),
             ...getMemberValidator("spaces").validate(obj.spaces, `${path}/spaces`),
             ...getMemberValidator("live").validate(obj.live, `${path}/live`),
+            ...getMemberValidator("presentation").validate(obj.presentation, `${path}/presentation`),
         ];
     };
 })(GameTypeMetadata || (GameTypeMetadata = {}));

package/dist-es/src/protocols/Aws_restJson1.js

@@ -619,6 +619,7 @@ export const serializeGetMetadataResponse = async (input, ctx) => {
         'live': _ => se_LiveCapability(_, context),
         'maxPlayers': [],
         'minPlayers': [],
+        'presentation': _ => se_Document(_, context),
         'spaces': _ => se_SpaceCapability(_, context),
         'spectatorSafe': [],
         'teamPlay': [],