@vgai/editor 0.2.0 → 0.4.0-canary.20260715.0

package/template/manifest-entry-modules-plugin.ts

@@ -0,0 +1,53 @@
+import type { Plugin } from 'vite';
+
+const MANIFEST_ENTRIES_ID = 'virtual:vgai-manifest-entries';
+const RESOLVED_MANIFEST_ENTRIES_ID = `\0${MANIFEST_ENTRIES_ID}`;
+
+function collectManifestEntries(manifest: unknown): string[] {
+  const rawWorlds =
+    manifest && typeof manifest === 'object'
+      ? (manifest as { roots?: unknown }).roots
+      : undefined;
+  const entries = [
+    ...new Set(
+      (Array.isArray(rawWorlds) ? rawWorlds : [])
+        .map((world) =>
+          world && typeof world === 'object' ? (world as { entry?: unknown }).entry : undefined,
+        )
+        .filter((entry): entry is string => typeof entry === 'string'),
+    ),
+  ];
+
+  for (const entry of entries) {
+    if (entry.startsWith('/') || entry.includes('\\') || entry.split('/').includes('..')) {
+      throw new Error(`vgai.game.json world entry must be project-relative: ${entry}`);
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Render imports for the manifest's exact `roots[].entry` declarations.
+ * The manifest—not a filename convention—is the only discovery source.
+ */
+export function renderManifestEntryModule(manifest: unknown): string {
+  const entries = collectManifestEntries(manifest);
+  const imports = entries.map(
+    (entry, index) => `import * as entry${index} from ${JSON.stringify(`/${entry}`)};`,
+  );
+  const members = entries.map((entry, index) => `${JSON.stringify(entry)}: entry${index}`);
+  return `${imports.join('\n')}\nexport const manifestEntryModules = {${members.join(',')}};\n`;
+}
+
+export function manifestEntryModulesPlugin(manifest: unknown): Plugin {
+  return {
+    name: 'vgai:manifest-entry-modules',
+    resolveId(id) {
+      return id === MANIFEST_ENTRIES_ID ? RESOLVED_MANIFEST_ENTRIES_ID : undefined;
+    },
+    load(id) {
+      return id === RESOLVED_MANIFEST_ENTRIES_ID ? renderManifestEntryModule(manifest) : undefined;
+    },
+  };
+}

package/template/package.json

@@ -11,15 +11,18 @@
     "dev": "vgai edit .",
     "game": "vite",
     "build": "tsc && vite build",
-    "typecheck": "tsc --noEmit && tsc --noEmit -p server/tsconfig.json",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p server/tsconfig.json && tsc --noEmit -p tests/tsconfig.json",
     "emit-schemas": "npx tsx emit-schemas.ts",
     "validate-scenes": "npx tsx validate-scenes.ts .",
     "validate-manifest": "npx tsx validate-manifest.ts vgai.game.json",
-    "server": "npx tsx --tsconfig server/tsconfig.json server/main.ts"
+    "check-idioms": "npx tsx check-idioms.ts .",
+    "server": "npx tsx --tsconfig server/tsconfig.json server/main.ts",
+    "test": "vitest run tests/logic",
+    "test:acceptance": "vgai probe",
+    "playtest": "npx tsx scripts/playtest.ts"
   },
   "dependencies": {
     "@vgai/engine": "*",
-    "@vgai/scene-ui": "*",
     "@colyseus/schema": "^4.0.14",
     "@colyseus/sdk": "^0.17.34",
     "@dimforge/rapier3d-compat": "^0.14.0",
@@ -42,12 +45,18 @@
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "@types/three": "^0.170.0",
+    "@playwright/test": "^1.58.2",
+    "@vgai/probe": "*",
+    "@vgai/live": "*",
+    "@vgai/sdk": "*",
+    "@vgai/editor-sdk": "*",
     "@vitejs/plugin-react": "^5.1.4",
     "colyseus": "^0.17.8",
     "@colyseus/ws-transport": "^0.17.9",
     "storybook": "^9.1.20",
     "tsx": "^4.23.0",
     "typescript": "^5.6.0",
-    "vite": "^6.0.0"
+    "vite": "^6.0.0",
+    "vitest": "^3.2.6"
   }
 }

package/template/public/scenes/default.scn2d.json

@@ -0,0 +1,6 @@
+{
+  "version": 1,
+  "surface": "world2d",
+  "background": "#10131c",
+  "entities": []
+}

package/template/public/scenes/default.vscn.json

@@ -6,10 +6,12 @@
   },
   "entities": [
     {
+      "id": "d43d8032-0e0c-4936-b996-87924d458668",
       "name": "AmbientLight",
       "light": { "type": "hemisphere", "color": "#ffffff", "groundColor": "#444444", "intensity": 0.5 }
     },
     {
+      "id": "d3231678-2f7f-4839-994b-1edf2abcc73c",
       "name": "Sun",
       "light": { "type": "directional", "color": "#ffffff", "intensity": 1 },
       "transform": { "position": [5, 10, 5] },
@@ -20,6 +22,7 @@
       }
     },
     {
+      "id": "2efb889f-5ca2-4715-a614-a379fdcb195b",
       "name": "Ground",
       "mesh": { "type": "box", "args": [20, 0.2, 20] },
       "material": { "type": "standard", "color": "#888888" },
@@ -27,6 +30,7 @@
       "shadow": { "enabled": true }
     },
     {
+      "id": "50a15029-7b16-4bb4-b013-b222b3ae0ad3",
       "name": "Box",
       "mesh": { "type": "box", "args": [1, 1, 1] },
       "material": { "type": "standard", "color": "#4488ff" },
@@ -35,9 +39,11 @@
       "components": { "DataSpinner": { "spinScale": 1 } }
     },
     {
+      "id": "af6855d6-9bf9-47f3-bcb1-d5e6843c97bd",
       "name": "Camera",
       "transform": { "position": [3, 3, 3] },
-      "camera": { "type": "perspective", "fov": 60, "near": 0.1, "far": 1000 }
+      "camera": { "type": "perspective", "fov": 60, "near": 0.1, "far": 1000 },
+      "components": { "SceneCamera": { "x": 3, "y": 3, "z": 3, "lookAtY": 0.5 } }
     }
   ]
 }

package/template/public/scenes/untitled.vscn.json

@@ -3,6 +3,7 @@
   "name": "Untitled",
   "entities": [
     {
+      "id": "cf60bb73-ace4-4078-a1a1-2a21af3b4cfb",
       "name": "Camera",
       "camera": {
         "type": "perspective"
@@ -13,9 +14,18 @@
           2,
           5
         ]
+      },
+      "components": {
+        "SceneCamera": {
+          "x": 0,
+          "y": 2,
+          "z": 5,
+          "lookAtY": 0
+        }
       }
     },
     {
+      "id": "49bbe8e0-0b0c-4780-88bb-d34790cce748",
       "name": "Box",
       "mesh": {
         "type": "box"

package/template/scripts/playtest.ts

@@ -0,0 +1,40 @@
+/**
+ * Inner-loop autoplay (see AGENTS.md's "Autoplay bots" — Level 2). A plain
+ * `@vgai/live` script: no test runner, no Playwright config, no fixture, no
+ * second browser. It ATTACHES to the live `vgai edit` session/tab you
+ * already have open (run `vgai edit .` first if you don't) and drives it
+ * with the SAME `GameClient` vocabulary `tests/acceptance/example.spec.ts`
+ * uses — compare the two side by side; the difference in ceremony is the
+ * whole point.
+ *
+ * Run: `npm run playtest` (or `npx tsx scripts/playtest.ts`). Nothing here
+ * is committed evidence — it's scratch space for "does my game work right
+ * now". Once an interaction proves a feature, graduate it into a spec under
+ * `tests/acceptance/` (`vgai probe --init` scaffolds the first one).
+ *
+ * Drives the template's shipped example component, `DataSpinner`
+ * (`src/scripts/components/data-spinner.ts`) — replace this with your own
+ * provider/command/action names as your first real edit.
+ */
+
+import { editor, game } from '@vgai/live';
+
+await editor.play(); // enters play mode; the ack waits for the game's full async setup
+
+// Fixture (declared cheat, D16) — jump to a known state. Never a substitute
+// for the honest-input proof below.
+await game.command('spinner.reset');
+
+// Proof: the same honest input path a human's keys hit (see
+// public/inputmaps/default.inputmap.json's 'attack' binding).
+await game.input.hold('attack', { simSeconds: 4 });
+
+await game.waitFor((s) => (s('spinner') as { lapsCompleted: number }).lapsCompleted >= 1, {
+  simSeconds: 10,
+});
+
+const spinner = (await game.state('spinner')) as { lapsCompleted: number };
+console.log(`spinner lapsCompleted: ${spinner.lapsCompleted}`);
+
+const shot = await game.screenshot('playtest-after-boosted-spin');
+console.log(`screenshot: ${shot}`);

package/template/server/loopback.ts

@@ -0,0 +1,75 @@
+/**
+ * Loopback Colyseus server harness for headless multiplayer tests — a
+ * near-verbatim copy of the engine repo's own
+ * `packages/editor/test/helpers/colyseus-loopback.ts` (Acceptance Driver
+ * build plan Task 4.4), shipped INTO every scaffolded project so a
+ * multiplayer game has a headless L1-equivalent (`docs/ACCEPTANCE-DRIVER-SPEC.md`
+ * §2.3's "Multiplayer lane") before `--players N` exists on `vgai probe`.
+ *
+ * Starts the REAL `startColyseus` bootstrap (`./colyseus-setup.js`) with the
+ * shipped room registry (`./rooms.js` — `ArenaRoom` + `GameRoom`) on an
+ * OS-assigned ephemeral port, in-process. No mocks: this is the exact same
+ * `Server` / `WebSocketTransport` a real `npm run server` would boot, just on
+ * `port: 0` so concurrent test runs never collide on `2567`.
+ *
+ * Usage:
+ * ```ts
+ * const server = await startLoopbackColyseus();
+ * try {
+ *   const client = new Client(server.url);
+ *   const room = await client.joinOrCreate('game_room', {}, undefined, undefined, {
+ *     allowDebugCommands: true,
+ *   });
+ *   // ...
+ * } finally {
+ *   server.stop();
+ * }
+ * ```
+ */
+
+import { startColyseus } from './colyseus-setup.js';
+import { rooms } from './rooms.js';
+
+export interface LoopbackColyseus {
+  /** `ws://127.0.0.1:<port>` — the ephemeral port the server actually bound. */
+  url: string;
+  /** Tear down the server (closes the underlying HTTP/WS server). */
+  stop: () => void;
+}
+
+/**
+ * `@colyseus/core`'s matchmaker setup unconditionally `import("@pm2/io")`s and
+ * registers metrics, which makes `@pm2/io` probe `process.send` and start
+ * speaking the PM2 agent protocol (`axm:*` messages) over it. Under vitest's
+ * forked worker pool, `process.send` is real (the runner's own parent<->child
+ * channel), so those messages get relayed to the parent and crash its
+ * deserializer — nothing to do with this test's own logic. Patch `process.send`
+ * to drop only `axm:*` payloads for the harness's lifetime; everything else
+ * (vitest's own protocol) passes through untouched.
+ */
+function suppressPm2IoIpcNoise(): () => void {
+  const original = process.send?.bind(process);
+  if (!original) return () => {};
+  const patched = (message: unknown, ...rest: unknown[]): boolean => {
+    const type = (message as { type?: unknown } | null)?.type;
+    if (typeof type === 'string' && type.startsWith('axm:')) return true;
+    return (original as (...a: unknown[]) => boolean)(message, ...rest);
+  };
+  process.send = patched as NonNullable<typeof process.send>;
+  return () => {
+    process.send = original;
+  };
+}
+
+/** Boot the real Colyseus server on an ephemeral loopback port. */
+export async function startLoopbackColyseus(): Promise<LoopbackColyseus> {
+  const restorePm2IoIpc = suppressPm2IoIpcNoise();
+  const handle = await startColyseus({ rooms, port: 0 });
+  return {
+    url: `ws://127.0.0.1:${handle.port}`,
+    stop: () => {
+      handle.stop();
+      restorePm2IoIpc();
+    },
+  };
+}

package/template/server/rooms/arena-room.ts

@@ -17,6 +17,11 @@
  *   - Configurable bot count (0–6), spawned on create, stored in the same players MapSchema.
  *   - Server picks behavior (idle/patrol/chase/flee) + target position.
  *   - Client handles smooth navmesh pathfinding.
+ *
+ * Also handles `__vgai:debugCommand` { name, args, requestId } — a
+ * `locus: 'server'` debug command's client leg (`docs/SYNTHETIC-PLAYER-SPEC.md`
+ * §3.1's "Multiplayer locus" note, Acceptance Driver build plan Task 4.2);
+ * see `DEBUG_COMMANDS`/`onCreate` below.
  */
 
 import { Room, type Client } from 'colyseus';
@@ -111,6 +116,25 @@ function randomTagger(state: ArenaState): string {
   return ids[Math.floor(Math.random() * ids.length)]!;
 }
 
+/**
+ * The `locus: 'server'` debug-command table (Acceptance Driver build plan
+ * Task 4.2) — mirrors `GameRoom`'s `DEBUG_COMMANDS` (`../game-room.ts`), one
+ * worked example per room. Mutates the AUTHORITATIVE (server) copy of state,
+ * never client prediction. Gated by `allowDebugCommands` — see `onCreate`.
+ */
+const DEBUG_COMMANDS: Record<
+  string,
+  (room: ArenaRoom, client: Client, args: unknown[]) => unknown
+> = {
+  'give-score': (room, client, args) => {
+    const amount = typeof args[0] === 'number' ? args[0] : 1;
+    const player = room.state.players.get(client.sessionId);
+    if (!player) throw new Error(`give-score: no player for session "${client.sessionId}"`);
+    player.score += amount;
+    return { score: player.score };
+  },
+};
+
 // --- Room ---
 
 export class ArenaRoom extends Room {
@@ -120,11 +144,55 @@ export class ArenaRoom extends Room {
   private colorIndex = 0;
   private npcBrains = new Map<string, NPCBrain>();
 
-  onCreate(options?: { botCount?: number }) {
+  onCreate(options?: { botCount?: number; allowDebugCommands?: boolean }) {
     // Spawn NPC bots (count from room creator, default 2, max 6)
     const npcCount = Math.max(0, Math.min(MAX_NPCS, options?.botCount ?? 2));
     this.spawnNPCs(npcCount);
 
+    // Off by default (FROZEN DECISION: env-var OR room-option) — `vgai probe`/
+    // the loopback harness (`../loopback.ts`) opt in via the room option; a
+    // plain `npm run server` boot never accepts debug commands unless
+    // VGAI_ALLOW_DEBUG_COMMANDS is set in its environment.
+    const debugCommandsAllowed =
+      options?.allowDebugCommands === true || Boolean(process.env['VGAI_ALLOW_DEBUG_COMMANDS']);
+
+    this.onMessage(
+      '__vgai:debugCommand',
+      (client, message: { name: string; args?: unknown[]; requestId: string }) => {
+        if (!debugCommandsAllowed) {
+          client.send('__vgai:debugCommandResult', {
+            requestId: message.requestId,
+            ok: false,
+            error: 'debug commands disabled',
+          });
+          return;
+        }
+        const handler = DEBUG_COMMANDS[message.name];
+        if (!handler) {
+          client.send('__vgai:debugCommandResult', {
+            requestId: message.requestId,
+            ok: false,
+            error: `debug: no server command registered under "${message.name}"`,
+          });
+          return;
+        }
+        try {
+          const result = handler(this, client, message.args ?? []);
+          client.send('__vgai:debugCommandResult', {
+            requestId: message.requestId,
+            ok: true,
+            result,
+          });
+        } catch (err) {
+          client.send('__vgai:debugCommandResult', {
+            requestId: message.requestId,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    );
+
     // Handle start_game from host
     this.onMessage('start_game', (client) => {
       if (client.sessionId !== this.state.hostId) return;

package/template/server/rooms/game-room.ts

@@ -7,6 +7,10 @@
  *
  * Messages (client → server only):
  *   position  { x, y, z }   — client movement input
+ *   __vgai:debugCommand { name, args, requestId } — a `locus: 'server'`
+ *     debug command's client leg (`docs/SYNTHETIC-PLAYER-SPEC.md` §3.1's
+ *     "Multiplayer locus" note, Acceptance Driver build plan Task 4.2); see
+ *     `DEBUG_COMMANDS`/`onCreate` below.
  *
  * Everything else (players, orbs, scores) is synchronized via Schema
  * state: new joiners receive the full state automatically, and ongoing
@@ -54,6 +58,25 @@ class GameState extends Schema {
 
 let nextOrbId = 0;
 
+/**
+ * The `locus: 'server'` debug-command table (Task 4.2) — one worked example,
+ * `give-score`, mirroring the client-side `DataSpinner.spinner.reset` fixture
+ * (`src/scripts/components/data-spinner.ts`): mutates the AUTHORITATIVE
+ * (server) copy of state, never client prediction. Gated by
+ * `allowDebugCommands` — see `onCreate` — so a production `npm run server`
+ * boot never accepts these unless explicitly opted in.
+ */
+const DEBUG_COMMANDS: Record<string, (room: GameRoom, client: Client, args: unknown[]) => unknown> =
+  {
+    'give-score': (room, client, args) => {
+      const amount = typeof args[0] === 'number' ? args[0] : 1;
+      const player = room.state.players.get(client.sessionId);
+      if (!player) throw new Error(`give-score: no player for session "${client.sessionId}"`);
+      player.score += amount;
+      return { score: player.score };
+    },
+  };
+
 function randomSpawnPosition(): { x: number; y: number; z: number } {
   const angle = Math.random() * Math.PI * 2;
   return {
@@ -83,7 +106,14 @@ export class GameRoom extends Room {
   // from `setSimulationInterval` — it exists in both runtimes.
   private orbRespawnTicks: number[] = [];
 
-  onCreate() {
+  onCreate(options?: { allowDebugCommands?: boolean }) {
+    // Off by default (FROZEN DECISION: env-var OR room-option) — `vgai probe`/
+    // the loopback harness (`../loopback.ts`) opt in via the room option; a
+    // plain `npm run server` boot never accepts debug commands unless
+    // VGAI_ALLOW_DEBUG_COMMANDS is set in its environment.
+    const debugCommandsAllowed =
+      options?.allowDebugCommands === true || Boolean(process.env['VGAI_ALLOW_DEBUG_COMMANDS']);
+
     // Handle client messages
     this.onMessage('position', (client, position: { x: number; y: number; z: number }) => {
       const player = this.state.players.get(client.sessionId);
@@ -94,6 +124,43 @@ export class GameRoom extends Room {
       }
     });
 
+    this.onMessage(
+      '__vgai:debugCommand',
+      (client, message: { name: string; args?: unknown[]; requestId: string }) => {
+        if (!debugCommandsAllowed) {
+          client.send('__vgai:debugCommandResult', {
+            requestId: message.requestId,
+            ok: false,
+            error: 'debug commands disabled',
+          });
+          return;
+        }
+        const handler = DEBUG_COMMANDS[message.name];
+        if (!handler) {
+          client.send('__vgai:debugCommandResult', {
+            requestId: message.requestId,
+            ok: false,
+            error: `debug: no server command registered under "${message.name}"`,
+          });
+          return;
+        }
+        try {
+          const result = handler(this, client, message.args ?? []);
+          client.send('__vgai:debugCommandResult', {
+            requestId: message.requestId,
+            ok: true,
+            result,
+          });
+        } catch (err) {
+          client.send('__vgai:debugCommandResult', {
+            requestId: message.requestId,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    );
+
     // Spawn initial orbs
     for (let i = 0; i < MAX_ORBS; i++) {
       this.spawnOrb();

package/template/src/data/README.md

@@ -8,7 +8,7 @@ copy that trio for each new asset and register it in `assets.ts` (one list,
 feeding both `npm run emit-schemas` and the build-time check that fails
 `npm run build` loud on invalid data or a dangling `"file#key"` ref; `vgai
 doctor <folder>` runs the same checks). Never hardcode a tunable as a constant in
-game code — see "Tunable values → a data asset" in this project's CLAUDE.md,
+game code — see "Tunable values → a data asset" in this project's AGENTS.md,
 and `docs/DATA-TOOLS-DESIGN.md` in the engine checkout for the design.
 
 Two blessed shapes, and only these (they're what the editor's DATA tab can
@@ -31,10 +31,15 @@ written; fix the sheet and re-import. `"$schema"` is never a CSV column —
 it's carried over from the file automatically.
 
 Cross-asset fields (one table's row pointing at another asset — an enemy's
-drop pointing at an item) should use `dataRef('<target-stem>')`
-(`@engine/data/data-ref`) in the schema instead of a bare `z.string()`: the
+drop pointing at an item) should use `dataRef('<target-stem>')` —
+`import { dataRef } from './data-ref'` (see `./data-ref.ts`; never
+`@engine/data/data-ref` or `@vgai/engine/data/data-ref` directly — a schema
+file is reached from `vite.config.ts` at Vite config-load time, which only
+bundles relative imports, so `./data-ref` is the one import spelling that
+resolves there too) — in the schema instead of a bare `z.string()`: the
 DATA tab then renders that field as a `stem#key` PICKER (listing the target
 file's own keys) instead of free text, and `vgai doctor`/`npm run build`
 catch it if the target file is ever renamed or deleted — not just if the key
 inside it goes missing. Read it back with `getRef(targetHandle, row.field)`
-(pass the target's own `defineData` handle, not a string) from game code.
+(also from `./data-ref`; pass the target's own `defineData` handle, not a
+string) from game code.

package/template/src/data/data-ref.ts

@@ -0,0 +1,35 @@
+/**
+ * Re-exports the engine's `dataRef`/`getRef` (docs/DATA-TOOLS-DESIGN.md §2.2)
+ * — the ONE place a `*.schema.ts` should import them from. Import via
+ * `from './data-ref'` (a plain, project-internal relative import — every
+ * `*.schema.ts` lives right next to this file in `src/data/`), never
+ * `@engine/data/data-ref` or `@vgai/engine/data/data-ref` directly.
+ *
+ * Why this file has to exist at all, ENGINE-RELATIVE (not a bare specifier),
+ * same reasoning as `vite.config.ts`'s `vgaiDataCheck` import: this project's
+ * data-asset schemas (`src/data/*.schema.ts`) are reached from
+ * `vite.config.ts` itself (via `./src/data/assets`) when Vite loads its OWN
+ * config, so `npm run build`'s dangling-ref gate can run the EXACT executable
+ * Zod schema (§9.1) — and that config-load step only BUNDLES relative
+ * imports. A bare specifier is externalized and handed to plain node, which
+ * cannot load the engine's shipped TypeScript source either way:
+ * `@engine/...` isn't even a real package outside Vite's app-build alias
+ * (which doesn't exist yet while Vite is still loading its own config), and
+ * `@vgai/engine/...` IS a real, installed package, but its `exports` map
+ * points at raw `.ts` — a file plain node's ESM loader cannot parse without a
+ * loader hook (the same `ERR_UNKNOWN_FILE_EXTENSION` `vite.config.ts`'s own
+ * comment describes for `vgaiDataCheck`).
+ *
+ * A relative import is the only thing that resolves in every context that
+ * touches a `dataRef` field: `tsc`, the app's Vite build, Vite's config-load
+ * (the one bare specifiers break), the editor (which aliases `@engine/*` for
+ * its OWN app build, but never for config-load either), and `tsx` (`npm run
+ * emit-schemas`, `vgai doctor`). Routing every schema file through this ONE
+ * module — instead of each one spelling out its own checkout-relative path —
+ * means only this file's import needs rewriting per project: the scaffolder
+ * does it automatically (`create-vgai-project/src/scaffold.ts`'s
+ * `rewriteDataRefModule`, mirroring `rewriteViteConfig`), the same way it
+ * already rewrites `vite.config.ts`'s engine-relative import. Never hand-edit
+ * the import below — `vgai upgrade` re-syncs it too.
+ */
+export { dataRef, getRef, type DataRef } from '../../../../engine/src/data/data-ref';

package/template/src/data/tuning.schema.ts

@@ -15,7 +15,7 @@
  * annotations `GameComponent.static schema` uses. They document the file,
  * constrain edits, and (W2+) become editor widgets.
  *
- * Rule of thumb (project CLAUDE.md carries the doctrine): if a designer
+ * Rule of thumb (project AGENTS.md carries the doctrine): if a designer
  * should be able to change it, it belongs here — NOT as a constant in a
  * component. Per-entity placement config stays on component schemas.
  */