@pop-party/create-game 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Turowetz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @pop-party/create-game
+
+This package powers `npm create @pop-party/game MyGame`. It creates an independent game directory, pins an exact `@pop-party/engine` version, and byte-copies the canonical CC0-1.0 starter content without symlinks or references to the engine repository.
+
+Current npm initializer resolution maps `npm create @pop-party/game` to this
+package, `@pop-party/create-game`, and executes its sole `create-game` bin. The
+packed executable is part of the release gate. Unknown flags, missing flag
+values, and ambiguous game names fail instead of falling back to defaults.
+
+Generated games use `pop-party validate content` for content-only checks and
+`pop-party build` for the full game/engine/plugin/content readiness gate. Build
+output is game-local and records the exact immutable content revision.
+Runtime game data is materialized from that same validated content snapshot;
+the generator does not create a second empty or drifting game-data source.
+
+Generated games run through `pop-party dev` locally and `pop-party start` in
+production. The first development run seeds ignored `.pop-party/content` from
+the configured immutable release; later runs keep that independent local copy.
+Production never reads the development workspace. Both commands validate the
+complete selected release before opening a port.
+
+`pop-party migrate` previews the registered, contiguous game migration path.
+It writes nothing unless `--output <new-directory>` is supplied, never mutates
+the source bundle, runs every migration twice to reject nondeterministic output,
+and validates the complete result against the installed engine before writing.
+
+Each generated game also owns a `render.yaml` and `DEPLOYMENT.md`. The Blueprint
+declares one manually scaled Node web service, the engine build/start commands,
+`/health`, and a 300-second graceful shutdown window. It contains no shared
+engine deployment and no committed provider or administrator secrets.

package/bin/create-game.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+"use strict";
+
+const path = require("path");
+const { generateGame } = require("../src/generate-game");
+const { HELP_TEXT, parseCreateGameArguments } = require("../src/cli-arguments");
+
+try {
+  const parsed = parseCreateGameArguments(process.argv.slice(2));
+  if (parsed.help) {
+    console.log(HELP_TEXT);
+    process.exitCode = 0;
+    return;
+  }
+  const result = generateGame({
+    ...parsed,
+    targetRoot: parsed.targetRoot || path.resolve(process.cwd(), resultName(parsed.displayName))
+  });
+  console.log(`Created ${result.displayName} at ${result.targetRoot}`);
+  console.log(`Engine: @pop-party/engine@${result.engineVersion}`);
+} catch (error) {
+  console.error(`Could not create game: ${error.message}`);
+  process.exitCode = 1;
+}
+
+function resultName(value) {
+  return String(value || "game").trim().replace(/\s+/g, "-");
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pop-party/create-game",
+  "version": "1.0.0",
+  "description": "Create an independent Pop Party game pinned to an exact engine version.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MarkTurowetz/pop-party-engine.git",
+    "directory": "packages/create-game"
+  },
+  "homepage": "https://github.com/MarkTurowetz/pop-party-engine/tree/main/packages/create-game#readme",
+  "bugs": {
+    "url": "https://github.com/MarkTurowetz/pop-party-engine/issues"
+  },
+  "type": "commonjs",
+  "main": "src/generate-game.js",
+  "bin": {
+    "create-game": "bin/create-game.js"
+  },
+  "files": [
+    "bin/*.js",
+    "src/**/*.js",
+    "starter/**/*",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/src/cli-arguments.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const HELP_TEXT = [
+  "Usage: npm create @pop-party/game <name> [options]",
+  "",
+  "Options:",
+  "  --engine-version <version>  Exact @pop-party/engine version",
+  "  --output <directory>        Empty target directory",
+  "  --starter <directory>       Alternate starter bundle (development/testing only)",
+  "  --help                      Show this help"
+].join("\n");
+
+const VALUE_FLAGS = Object.freeze({
+  "--engine-version": "engineVersion",
+  "--output": "targetRoot",
+  "--starter": "starterRoot"
+});
+
+function parseCreateGameArguments(argv = []) {
+  const options = {};
+  let displayName = "";
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = String(argv[index]);
+    if (value === "--help" || value === "-h") return Object.freeze({ help: true });
+    const equalsIndex = value.indexOf("=");
+    const flag = equalsIndex > 0 ? value.slice(0, equalsIndex) : value;
+    if (VALUE_FLAGS[flag]) {
+      const flagValue = equalsIndex > 0 ? value.slice(equalsIndex + 1) : String(argv[index + 1] ?? "");
+      if (!flagValue || (equalsIndex < 0 && flagValue.startsWith("-"))) throw new Error(`${flag} requires a value`);
+      options[VALUE_FLAGS[flag]] = flagValue;
+      if (equalsIndex < 0) index += 1;
+      continue;
+    }
+    if (value.startsWith("-")) throw new Error(`Unknown create-game option: ${value}`);
+    if (displayName) throw new Error(`Unexpected game name argument: ${value}`);
+    displayName = value.trim();
+  }
+  if (!displayName) throw new Error("Game display name is required");
+  return Object.freeze({
+    displayName,
+    engineVersion: options.engineVersion || "1.0.0",
+    starterRoot: options.starterRoot || undefined,
+    targetRoot: options.targetRoot || undefined
+  });
+}
+
+module.exports = Object.freeze({ HELP_TEXT, parseCreateGameArguments });

package/src/generate-game.js

@@ -0,0 +1,150 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const EXACT_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const GAME_ID_PATTERN = /^[a-z][a-z0-9-]{2,63}$/;
+function gameIdFromName(value) {
+  const normalized = String(value || "").normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+  const gameId = normalized.replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64).replace(/-+$/g, "");
+  if (!GAME_ID_PATTERN.test(gameId)) throw new Error("Game name must produce a 3-64 character id beginning with a letter");
+  return gameId;
+}
+
+function assertExactEngineVersion(value) {
+  const version = String(value || "").trim();
+  if (!EXACT_VERSION_PATTERN.test(version)) throw new Error("Engine version must be an exact semantic version without a range");
+  return version;
+}
+
+function assertEmptyTarget(targetRoot) {
+  if (!fs.existsSync(targetRoot)) return;
+  const stat = fs.lstatSync(targetRoot);
+  if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`Game target is not an empty directory: ${targetRoot}`);
+  if (fs.readdirSync(targetRoot).length) throw new Error(`Game target is not empty: ${targetRoot}`);
+}
+
+function copyTree(sourceRoot, targetRoot) {
+  const sourceStat = fs.lstatSync(sourceRoot);
+  if (sourceStat.isSymbolicLink()) throw new Error(`Starter content cannot contain symlinks: ${sourceRoot}`);
+  if (!sourceStat.isDirectory()) throw new Error(`Starter content root is not a directory: ${sourceRoot}`);
+  fs.mkdirSync(targetRoot, { recursive: true });
+  for (const entry of fs.readdirSync(sourceRoot, { withFileTypes: true })) {
+    const sourcePath = path.join(sourceRoot, entry.name);
+    const targetPath = path.join(targetRoot, entry.name);
+    const stat = fs.lstatSync(sourcePath);
+    if (stat.isSymbolicLink()) throw new Error(`Starter content cannot contain symlinks: ${sourcePath}`);
+    if (stat.isDirectory()) copyTree(sourcePath, targetPath);
+    else if (stat.isFile()) fs.copyFileSync(sourcePath, targetPath, fs.constants.COPYFILE_EXCL);
+    else throw new Error(`Unsupported starter content entry: ${sourcePath}`);
+  }
+}
+
+function writeText(targetRoot, relativePath, text) {
+  const absolutePath = path.join(targetRoot, relativePath);
+  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+  fs.writeFileSync(absolutePath, text, { encoding: "utf8", flag: "wx" });
+}
+
+function generatedConfigSource({ displayName, engineVersion, gameId }) {
+  return `"use strict";\n\nconst path = require("node:path");\nconst { createLocalContentBundleProvider } = require("@pop-party/engine");\nconst { defineGame } = require("@pop-party/engine/game");\nconst semanticRoles = require("./content/semantic-roles.json").roles;\nconst plugin = require("./src/plugin");\n\nfunction contentRoot() {\n  const configured = process.env.POP_PARTY_CONTENT_ROOT;\n  if (!configured) return path.join(__dirname, "content");\n  const root = path.resolve(__dirname, configured);\n  const relative = path.relative(__dirname, root);\n  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {\n    throw new Error("POP_PARTY_CONTENT_ROOT must remain inside the game workspace");\n  }\n  return root;\n}\n\nconst contentStore = createLocalContentBundleProvider({\n  root: contentRoot(),\n  gameBuild: "0.1.0",\n  engineVersion: ${JSON.stringify(engineVersion)},\n  pluginVersion: "0.1.0"\n});\n\nmodule.exports = defineGame({\n  gameId: ${JSON.stringify(gameId)},\n  displayName: ${JSON.stringify(displayName)},\n  version: "0.1.0",\n  engineCompatibility: ${JSON.stringify(engineVersion)},\n  content: {\n    mode: "bundle",\n    schemaVersion: 1,\n    store: contentStore\n  },\n  plugin,\n  semanticRoles\n});\n`;
+}
+
+function generatedContributionSource(kind) {
+  return `"use strict";\n\n// Add ${kind} contributions as { id: "game-namespace.name", value: ... }.\nmodule.exports = Object.freeze([]);\n`;
+}
+
+function generatedBootstrapRendererSource({ gameId, role }) {
+  const kind = role === "stage" ? "Stage" : "Controller";
+  return `"use strict";\n\nmodule.exports = Object.freeze([{\n  id: ${JSON.stringify(`${gameId}.bootstrap-${role}`)},\n  value: Object.freeze({\n    renderBootstrap({ game }) {\n      if (game.id !== ${JSON.stringify(gameId)}) throw new Error("${kind} renderer received another game");\n      return Object.freeze({\n        heading: game.displayName,\n        message: ${JSON.stringify(`${kind} service is ready.`)}\n      });\n    }\n  })\n}]);\n`;
+}
+
+function generatedRenderBlueprintSource(gameId) {
+  return `services:\n  - type: web\n    name: ${gameId}\n    runtime: node\n    plan: starter\n    numInstances: 1\n    buildCommand: npm install --no-audit --no-fund && npm run build\n    startCommand: npm start\n    healthCheckPath: /health\n    maxShutdownDelaySeconds: 300\n    envVars:\n      - key: NODE_ENV\n        value: production\n`;
+}
+
+function generatedPluginSource(pluginNamespace) {
+  return `"use strict";\n\nconst { defineGamePlugin } = require("@pop-party/engine/plugin");\nconst actions = require("../actions");\nconst stageRenderers = require("../stage");\nconst controllerRenderers = require("../controller");\nconst toolPanels = require("../tools");\n\nconst contributionGroups = Object.freeze([\n  ["actions", actions],\n  ["stageRenderers", stageRenderers],\n  ["controllerRenderers", controllerRenderers],\n  ["toolPanels", toolPanels]\n]);\n\nmodule.exports = defineGamePlugin({\n  namespace: ${JSON.stringify(pluginNamespace)},\n  register(registry) {\n    for (const [kind, contributions] of contributionGroups) {\n      for (const contribution of contributions) registry[kind](contribution.id, contribution.value);\n    }\n  }\n});\n`;
+}
+
+function generatedConfigTestSource({ engineVersion, gameId, pluginNamespace }) {
+  return `"use strict";\n\nconst assert = require("node:assert/strict");\nconst test = require("node:test");\nconst { createGameApplicationRuntime } = require("@pop-party/engine/server/application");\nconst { createGameReadinessRuntime } = require("@pop-party/engine/server/readiness");\nconst game = require("../game.config");\n\ntest("game configuration owns an exact engine and plugin boundary", async () => {\n  assert.equal(game.gameId, ${JSON.stringify(gameId)});\n  assert.equal(game.engineCompatibility, ${JSON.stringify(engineVersion)});\n  assert.equal(game.plugin.namespace, ${JSON.stringify(pluginNamespace)});\n  assert.equal(game.gameData, null);\n  assert.equal(game.registrations.stageRenderers.length, 1);\n  assert.equal(game.registrations.stageRenderers[0].id, ${JSON.stringify(`${gameId}.bootstrap-stage`)});\n  assert.equal(game.registrations.controllerRenderers.length, 1);\n  assert.equal(game.registrations.controllerRenderers[0].id, ${JSON.stringify(`${gameId}.bootstrap-controller`)});\n  assert.deepEqual({\n    actions: game.registrations.actions,\n    stateSchemas: game.registrations.stateSchemas,\n    validators: game.registrations.validators,\n    migrations: game.registrations.migrations,\n    toolPanels: game.registrations.toolPanels,\n    diagnostics: game.registrations.diagnostics\n  }, {\n    actions: [],\n    stateSchemas: [],\n    validators: [],\n    migrations: [],\n    toolPanels: [],\n    diagnostics: []\n  });\n  const readiness = createGameReadinessRuntime({ gameDefinition: game, engineVersion: ${JSON.stringify(engineVersion)} });\n  const active = await readiness.check();\n  assert.equal(active.release.gameId, ${JSON.stringify(gameId)});\n  assert.equal(active.release.engineVersion, ${JSON.stringify(engineVersion)});\n  assert.ok(active.gameData.defaultGameFlow.states.length > 0);\n  assert.ok(active.gameData.defaultArtCompositions.length > 0);\n  assert.equal(readiness.state.status, "ready");\n});\n\ntest("generated game starts as an independent validated web service", async () => {\n  const runtime = createGameApplicationRuntime({\n    gameDefinition: game,\n    engineVersion: ${JSON.stringify(engineVersion)},\n    host: "127.0.0.1",\n    port: 0\n  });\n  try {\n    const startup = await runtime.start();\n    const health = await fetch(\`${"${startup.localUrl}"}/health\`);\n    const stage = await fetch(\`${"${startup.localUrl}"}/stage\`);\n    const controller = await fetch(\`${"${startup.localUrl}"}/controller\`);\n    const tools = await fetch(\`${"${startup.localUrl}"}/tools\`);\n    assert.equal(health.status, 200);\n    assert.equal((await health.json()).release.contentRevision, runtime.active.release.contentRevision);\n    assert.equal(stage.status, 200);\n    assert.match(await stage.text(), /data-pop-party-role="stage"/);\n    assert.equal(controller.status, 200);\n    assert.match(await controller.text(), /data-pop-party-role="controller"/);\n    assert.equal(tools.status, 503);\n    assert.equal((await tools.json()).diagnostic.code, "GAME_TOOLING_NOT_CONFIGURED");\n  } finally {\n    await runtime.stop();\n  }\n});\n`;
+}
+
+function rewriteBundleGameId(contentRoot, gameId) {
+  const manifestPath = path.join(contentRoot, "content-bundle.json");
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  manifest.gameId = gameId;
+  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+
+function generateGame(options = {}) {
+  const displayName = String(options.displayName || options.name || "").trim();
+  if (!displayName) throw new Error("Game display name is required");
+  const gameId = options.gameId ? String(options.gameId).trim() : gameIdFromName(displayName);
+  if (!GAME_ID_PATTERN.test(gameId)) throw new Error(`Game id must match ${GAME_ID_PATTERN}`);
+  const engineVersion = assertExactEngineVersion(options.engineVersion);
+  const targetRoot = path.resolve(options.targetRoot || gameId);
+  const starterRoot = path.resolve(options.starterRoot || path.join(__dirname, "..", "starter", "content"));
+  const pluginNamespace = gameId.slice(0, 48).replace(/-+$/g, "");
+  assertEmptyTarget(targetRoot);
+  const parentRoot = path.dirname(targetRoot);
+  fs.mkdirSync(parentRoot, { recursive: true });
+  const stagingRoot = fs.mkdtempSync(path.join(parentRoot, `.${path.basename(targetRoot)}.pop-party-`));
+  try {
+    copyTree(starterRoot, path.join(stagingRoot, "content"));
+    rewriteBundleGameId(path.join(stagingRoot, "content"), gameId);
+
+    const manifest = {
+      name: gameId,
+      version: "0.1.0",
+      private: true,
+      description: `${displayName} built with Pop Party Engine.`,
+      engines: { node: ">=22" },
+      scripts: {
+        build: "pop-party build",
+        dev: "pop-party dev",
+        migrate: "pop-party migrate",
+        start: "pop-party start",
+        test: "node --test",
+        validate: "pop-party validate content"
+      },
+      dependencies: { "@pop-party/engine": engineVersion }
+    };
+    writeText(stagingRoot, "package.json", `${JSON.stringify(manifest, null, 2)}\n`);
+    writeText(stagingRoot, "game.config.js", generatedConfigSource({ displayName, engineVersion, gameId }));
+    writeText(stagingRoot, "src/actions/index.js", generatedContributionSource("server and flow action"));
+    writeText(stagingRoot, "src/stage/index.js", generatedBootstrapRendererSource({ gameId, role: "stage" }));
+    writeText(stagingRoot, "src/controller/index.js", generatedBootstrapRendererSource({ gameId, role: "controller" }));
+    writeText(stagingRoot, "src/tools/index.js", generatedContributionSource("authenticated tool panel"));
+    writeText(stagingRoot, "src/plugin/index.js", generatedPluginSource(pluginNamespace));
+    writeText(stagingRoot, "tests/config.test.js", generatedConfigTestSource({ engineVersion, gameId, pluginNamespace }));
+    writeText(stagingRoot, ".gitignore", "node_modules/\n.env\n.pop-party/\ndist/\noutputs/\n");
+    writeText(stagingRoot, "README.md", `# ${displayName}\n\nIndependent Pop Party game using \`@pop-party/engine@${engineVersion}\`.\n\nRun \`npm run dev\` locally or \`npm start\` in production. Development seeds ignored \`.pop-party/content\` once and then preserves that independent local copy; production uses the configured active store. The engine validates the selected release before binding the service port. Game-owned contributions live under \`src/actions\`, \`src/stage\`, \`src/controller\`, and \`src/tools\`; register them through the namespaced plugin in \`src/plugin\`. Content and starter blobs under \`content\` are independent copies owned by this game. Authenticated tools fail closed until the game explicitly configures them.\n`);
+    writeText(stagingRoot, "render.yaml", generatedRenderBlueprintSource(gameId));
+    writeText(stagingRoot, "DEPLOYMENT.md", `# ${displayName} deployment\n\nThis game deploys as one independent Render web service defined by \`render.yaml\`. Keep \`numInstances: 1\` and autoscaling disabled while rooms are in-memory. Render builds with \`npm install --no-audit --no-fund && npm run build\`, starts with \`npm start\`, and checks \`/health\`.\n\nProduction must use reviewed provider credentials and an immutable active release. Do not point \`POP_PARTY_CONTENT_ROOT\` at \`.pop-party/content\`; that override is only for the engine-owned local development command. Configure provider, OAuth, and content-writer secrets in Render rather than committing them.\n`);
+    writeText(stagingRoot, "LICENSE", fs.readFileSync(path.join(__dirname, "..", "LICENSE"), "utf8"));
+    writeText(stagingRoot, "CONTENT-LICENSE", "Canonical starter art and content were copied into this game under CC0-1.0 (https://creativecommons.org/publicdomain/zero/1.0/). This copy is owned and editable by this game.\n");
+    writeText(
+      stagingRoot,
+      "STARTER-ASSET-NOTICES.json",
+      fs.readFileSync(path.join(__dirname, "..", "starter", "ASSET-NOTICES.json"), "utf8")
+    );
+    if (fs.existsSync(targetRoot)) fs.rmdirSync(targetRoot);
+    fs.renameSync(stagingRoot, targetRoot);
+  } catch (error) {
+    fs.rmSync(stagingRoot, { recursive: true, force: true });
+    throw error;
+  }
+  return Object.freeze({ displayName, engineVersion, gameId, pluginNamespace, targetRoot });
+}
+
+module.exports = Object.freeze({
+  EXACT_VERSION_PATTERN,
+  GAME_ID_PATTERN,
+  assertExactEngineVersion,
+  copyTree,
+  gameIdFromName,
+  generateGame
+});

package/starter/ASSET-NOTICES.json

@@ -0,0 +1,73 @@
+{
+  "schemaVersion": 1,
+  "collection": "Pop Party Engine canonical starter art",
+  "license": "CC0-1.0",
+  "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
+  "publisher": "Mark Turowetz",
+  "assets": [
+    {
+      "id": "avatar-frame",
+      "name": "Shared Avatar Frame",
+      "sourceName": "avatar-frame.svg",
+      "blobPath": "blobs/2d1298fc8597b4b13dc74c8a4093ce7c8d6027ef955c4af31ed6a6d03034d527.svg",
+      "sha256": "2d1298fc8597b4b13dc74c8a4093ce7c8d6027ef955c4af31ed6a6d03034d527",
+      "mimeType": "image/svg+xml"
+    },
+    {
+      "id": "avatar-rex",
+      "name": "Rex Dinosaur",
+      "sourceName": "dino-rex.svg",
+      "blobPath": "blobs/8785460bf8b2311bfd2a5c06e97f9faac0deafd584b8f3de428c38399e2df16d.svg",
+      "sha256": "8785460bf8b2311bfd2a5c06e97f9faac0deafd584b8f3de428c38399e2df16d",
+      "mimeType": "image/svg+xml"
+    },
+    {
+      "id": "avatar-stego",
+      "name": "Stego Dinosaur",
+      "sourceName": "dino-stego.svg",
+      "blobPath": "blobs/4d1b3ad12d64d7f145e282dc44b2c510d8cc36c0a609fcef831fe9c59270bf35.svg",
+      "sha256": "4d1b3ad12d64d7f145e282dc44b2c510d8cc36c0a609fcef831fe9c59270bf35",
+      "mimeType": "image/svg+xml"
+    },
+    {
+      "id": "avatar-trike",
+      "name": "Trike Dinosaur",
+      "sourceName": "dino-trike.svg",
+      "blobPath": "blobs/a531c3ee6f5bfa5b478b6ecda5799f1031ceea367ca9d93585545b3de0ed34d7.svg",
+      "sha256": "a531c3ee6f5bfa5b478b6ecda5799f1031ceea367ca9d93585545b3de0ed34d7",
+      "mimeType": "image/svg+xml"
+    },
+    {
+      "id": "avatar-raptor",
+      "name": "Raptor Dinosaur",
+      "sourceName": "dino-raptor.svg",
+      "blobPath": "blobs/d54e3eae53b88a705370aa028c3ea55297d549e3521aca6a41435f87e4a18167.svg",
+      "sha256": "d54e3eae53b88a705370aa028c3ea55297d549e3521aca6a41435f87e4a18167",
+      "mimeType": "image/svg+xml"
+    },
+    {
+      "id": "avatar-bronto",
+      "name": "Bronto Dinosaur",
+      "sourceName": "dino-bronto.svg",
+      "blobPath": "blobs/1c14e1db26cfb96105b2cbf60591a18329834078cc65e14373715d4ec06f07ef.svg",
+      "sha256": "1c14e1db26cfb96105b2cbf60591a18329834078cc65e14373715d4ec06f07ef",
+      "mimeType": "image/svg+xml"
+    },
+    {
+      "id": "avatar-ankylo",
+      "name": "Ankylo Dinosaur",
+      "sourceName": "dino-ankylo.svg",
+      "blobPath": "blobs/8dbc40965debd1f9f516461ed2b6ca0dd95557f8a762dbeaf67459e4b343497a.svg",
+      "sha256": "8dbc40965debd1f9f516461ed2b6ca0dd95557f8a762dbeaf67459e4b343497a",
+      "mimeType": "image/svg+xml"
+    },
+    {
+      "id": "presentation-click-cursor",
+      "name": "Presentation Click Cursor",
+      "sourceName": "cursor-arrow.svg",
+      "blobPath": "blobs/7a3a06ea1280a916254e2af034762e798b11e45f5eb7a1f4e0ba1a3ad4b8af48.svg",
+      "sha256": "7a3a06ea1280a916254e2af034762e798b11e45f5eb7a1f4e0ba1a3ad4b8af48",
+      "mimeType": "image/svg+xml"
+    }
+  ]
+}