@waica/cli 0.3.0

package/dist/mcp/create-project.js

@@ -0,0 +1,151 @@
+import { access, mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PackageResolver, mixedSourceWarnings, provenanceRows, } from './package-resolver.js';
+import { assertAbsoluteProjectPath } from './project-path.js';
+const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+async function exists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+async function templateRoot() {
+    const built = path.join(moduleDirectory, 'template');
+    if (await exists(path.join(built, 'package.json.tpl')))
+        return built;
+    const source = path.resolve(moduleDirectory, '../../editor/template');
+    if (await exists(path.join(source, 'package.json.tpl')))
+        return source;
+    throw new Error('Waica project template is missing from this MCP installation.');
+}
+function projectUriMap(archetype) {
+    return Object.fromEntries(archetype.art.map((art) => [art.uri, `src/art/${art.file}`]));
+}
+function projectJson(value, archetype) {
+    const uris = projectUriMap(archetype);
+    return (JSON.stringify(value, (_key, entry) => typeof entry === 'string' ? (uris[entry] ?? entry) : entry, 2) + '\n');
+}
+async function chassisFiles(root, name, start, version, archetype) {
+    const read = (relative) => readFile(path.join(root, relative), 'utf8');
+    const [pkgTpl, indexHtml, mainTs, controlsText, statsJson, gameText, tsconfig, vite, readme, gitignore, params] = await Promise.all([
+        read('package.json.tpl'),
+        read('index.html'),
+        read('src/main.ts'),
+        read('src/controls.json'),
+        read('src/stats.json'),
+        read('src/game.json'),
+        read('tsconfig.json'),
+        read('vite.config.ts'),
+        read('README.md'),
+        read('_gitignore'),
+        read('public/waica.params.json'),
+    ]);
+    const controls = {
+        ...JSON.parse(controlsText),
+        bindings: archetype.bindings,
+    };
+    const game = {
+        ...JSON.parse(gameText),
+        archetype: archetype.id,
+    };
+    const scene = start === 'demo' ? archetype.scene : archetype.blankScene;
+    return {
+        'package.json': pkgTpl
+            .replaceAll('__PROJECT_NAME__', name)
+            .replaceAll('__WAICA_VERSION__', version),
+        'index.html': indexHtml,
+        'tsconfig.json': tsconfig,
+        'vite.config.ts': vite,
+        'README.md': readme,
+        '.gitignore': gitignore,
+        'src/main.ts': mainTs,
+        'src/controls.json': JSON.stringify(controls, null, 2) + '\n',
+        'src/stats.json': statsJson,
+        'src/game.json': JSON.stringify(game, null, 2) + '\n',
+        'src/scenes/main.scene.json': projectJson(scene, archetype),
+        'public/waica.params.json': params,
+    };
+}
+async function validateTarget(target) {
+    assertAbsoluteProjectPath(target);
+    const name = path.basename(path.normalize(target));
+    if (!/^[a-z0-9][a-z0-9-_.]*$/.test(name)) {
+        throw new Error(`Project name "${name}" is invalid; it must match /^[a-z0-9][a-z0-9-_.]*$/.`);
+    }
+    const parent = path.dirname(target);
+    let parentInfo;
+    try {
+        parentInfo = await stat(parent);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Project parent directory does not exist: ${parent}`);
+        }
+        throw error;
+    }
+    if (!parentInfo.isDirectory())
+        throw new Error(`Project parent is not a directory: ${parent}`);
+    try {
+        const targetInfo = await stat(target);
+        if (!targetInfo.isDirectory())
+            throw new Error(`Project target is a file: ${target}`);
+        const found = (await readdir(target)).sort();
+        if (found.length) {
+            throw new Error(`Project target is not empty; found: ${found.join(', ')}`);
+        }
+        return { exists: true, name };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { exists: false, name };
+        throw error;
+    }
+}
+/** Creates one project without installing dependencies or overwriting files. */
+export async function createProject(projectPath, start = 'demo') {
+    if (start !== 'demo' && start !== 'blank')
+        throw new Error('start must be "demo" or "blank"');
+    const target = await validateTarget(projectPath);
+    const resolver = new PackageResolver();
+    const [engine, behaviors, archetypePackage] = await Promise.all([
+        resolver.load('@waica/engine'),
+        resolver.load('@waica/behaviors'),
+        resolver.load('@waica/archetype-platformer', './manifest'),
+    ]);
+    const archetype = archetypePackage.module.ARCHETYPE;
+    const files = await chassisFiles(await templateRoot(), target.name, start, engine.provenance.version, archetype);
+    if (start === 'demo') {
+        for (const [ref, prefab] of Object.entries(archetype.prefabs)) {
+            files[`src/${ref}.${prefab.type}.json`] = projectJson(prefab, archetype);
+        }
+        for (const [name, html] of Object.entries(archetype.registry.ui ?? {})) {
+            files[`src/ui/${name}.html`] = html;
+        }
+        for (const art of archetype.art) {
+            files[`src/art/${art.file}`] = await readFile(path.join(archetypePackage.packageRoot, 'assets', art.file));
+        }
+    }
+    if (!target.exists)
+        await mkdir(projectPath);
+    for (const [relative, contents] of Object.entries(files)) {
+        const destination = path.join(projectPath, relative);
+        await mkdir(path.dirname(destination), { recursive: true });
+        await writeFile(destination, contents);
+    }
+    const provenance = provenanceRows([engine, behaviors, archetypePackage]);
+    return {
+        projectPath,
+        name: target.name,
+        start,
+        createdFiles: Object.keys(files).sort(),
+        nextSteps: `cd ${target.name}\nnpm install\nnpm run dev`,
+        provenance,
+        warnings: mixedSourceWarnings(provenance),
+    };
+}

package/dist/mcp/introspection.js

@@ -0,0 +1,201 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { activeArchetypeId, discoverArchetypes, pickArchetype, } from './archetypes.js';
+import { PackageResolver, mixedSourceWarnings, provenanceRows, } from './package-resolver.js';
+import { directFiles, requireWaicaProject } from './project-path.js';
+/**
+ * Deliberately mirrors the editor's classDefaults/CA-B2 contract: enumerable
+ * own fields from a fresh instance. It is not a general public-property
+ * reflection API; changing that model belongs to engine/editor design.
+ */
+function ownDefaults(Class) {
+    try {
+        return Object.fromEntries(Object.entries(new Class()).filter(([, value]) => value !== undefined));
+    }
+    catch {
+        return {};
+    }
+}
+function moduleDeclaresComponent(module, Class) {
+    return Object.values(module).some((candidate) => {
+        if (candidate === Class)
+            return true;
+        if (typeof candidate !== 'function')
+            return false;
+        return candidate.componentName === Class.componentName;
+    });
+}
+function sourcePackage(Class, engineModule, behaviorModule, archetypePackage) {
+    if (moduleDeclaresComponent(engineModule, Class))
+        return '@waica/engine';
+    if (moduleDeclaresComponent(behaviorModule, Class))
+        return '@waica/behaviors';
+    return archetypePackage;
+}
+export async function listComponents(projectPath) {
+    const check = await requireWaicaProject(projectPath);
+    const resolver = new PackageResolver(projectPath);
+    const discoveryWarnings = [];
+    const activeId = await activeArchetypeId(projectPath);
+    const [engine, behaviors, archetypes] = await Promise.all([
+        resolver.load('@waica/engine'),
+        resolver.load('@waica/behaviors'),
+        discoverArchetypes(projectPath, resolver, discoveryWarnings, activeId ? [activeId] : []),
+    ]);
+    const active = pickArchetype(archetypes, activeId, projectPath);
+    const components = Object.values(active.manifest.registry.components).map((Class) => {
+        const description = {
+            componentName: Class.componentName,
+            params: (Class.params ?? {}),
+            defaults: ownDefaults(Class),
+            sourcePackage: sourcePackage(Class, engine.module, behaviors.module, active.packageName),
+        };
+        if (Object.hasOwn(Class, 'displayName') && typeof Class.displayName === 'string') {
+            description.displayName = Class.displayName;
+        }
+        return description;
+    });
+    const projectOwned = (await Promise.all(['components', 'roles', 'states'].map(async (directory) => (await directFiles(path.join(projectPath, 'src', directory), '.ts')).map((file) => ({
+        path: `src/${directory}/${file}`,
+        validated: false,
+    })))))
+        .flat()
+        .sort((a, b) => a.path.localeCompare(b.path));
+    const provenance = provenanceRows([engine, behaviors, ...archetypes.map((entry) => entry.loaded)]);
+    return {
+        components,
+        projectOwned,
+        notes: check.notes,
+        provenance,
+        warnings: [...discoveryWarnings, ...mixedSourceWarnings(provenance)],
+    };
+}
+function componentNames(components) {
+    return (components ?? []).map((component) => component.type);
+}
+function paletteComponents(template, prefabs) {
+    const entity = template.make();
+    const fromPrefab = entity.prefab ? prefabs[entity.prefab]?.components : undefined;
+    return [...componentNames(fromPrefab), ...componentNames(entity.components)];
+}
+function roleDescription(name, role) {
+    return {
+        name,
+        description: role.description,
+        driver: role.driver ?? null,
+        signals: role.signals ?? {},
+        graph: role.graph ?? null,
+    };
+}
+export async function describeArchetype(projectPath, requestedId) {
+    const check = await requireWaicaProject(projectPath);
+    const resolver = new PackageResolver(projectPath);
+    const discoveryWarnings = [];
+    const activeId = await activeArchetypeId(projectPath);
+    const requiredIds = [activeId, requestedId].filter((id) => typeof id === 'string');
+    const [engine, behaviors, available] = await Promise.all([
+        resolver.load('@waica/engine'),
+        resolver.load('@waica/behaviors'),
+        discoverArchetypes(projectPath, resolver, discoveryWarnings, requiredIds),
+    ]);
+    // The active id must be known even when another archetype was requested:
+    // the response cannot truthfully name an active archetype otherwise.
+    const active = pickArchetype(available, activeId, projectPath);
+    const selected = requestedId
+        ? pickArchetype(available, requestedId, projectPath)
+        : active;
+    const manifest = selected.manifest;
+    const archetype = {
+        id: manifest.id,
+        label: manifest.label,
+        palette: manifest.palette.map((template) => ({
+            name: template.label,
+            components: paletteComponents(template, manifest.prefabs),
+        })),
+        prefabs: Object.entries(manifest.prefabs).map(([ref, prefab]) => ({
+            ref,
+            type: prefab.type,
+            components: componentNames(prefab.components),
+        })),
+        roles: Object.entries(manifest.bundle.roles).map(([name, role]) => roleDescription(name, role)),
+        bindings: manifest.bindings,
+        actionLabels: manifest.actionLabels,
+        ui: Object.keys(manifest.registry.ui ?? {}).sort(),
+        art: manifest.art,
+        entityIcons: manifest.entityIcons,
+    };
+    const installedArchetypes = available
+        .filter((entry) => entry.manifest.id !== active.manifest.id)
+        .map((entry) => ({
+        id: entry.manifest.id,
+        label: entry.manifest.label,
+        status: 'installed, not active',
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const provenance = provenanceRows([engine, behaviors, ...available.map((entry) => entry.loaded)]);
+    return {
+        activeArchetype: active.manifest.id,
+        archetype,
+        installedArchetypes,
+        notes: check.notes,
+        provenance,
+        warnings: [...discoveryWarnings, ...mixedSourceWarnings(provenance)],
+    };
+}
+async function tolerantJson(file) {
+    try {
+        const parsed = JSON.parse(await readFile(file, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function projectSummary(projectPath) {
+    const check = await requireWaicaProject(projectPath);
+    const [game, statsFile, controlsFile] = await Promise.all([
+        tolerantJson(path.join(projectPath, 'src/game.json')),
+        tolerantJson(path.join(projectPath, 'src/stats.json')),
+        tolerantJson(path.join(projectPath, 'src/controls.json')),
+    ]);
+    const prefabs = [];
+    for (const [directory, type] of [
+        ['characters', 'character'],
+        ['objects', 'object'],
+        ['tiles', 'tile'],
+    ]) {
+        const suffix = `.${type}.json`;
+        for (const file of await directFiles(path.join(projectPath, 'src', directory), suffix)) {
+            prefabs.push({ ref: `${directory}/${file.slice(0, -suffix.length)}`, type });
+        }
+    }
+    const rawStats = statsFile.stats && typeof statsFile.stats === 'object'
+        ? statsFile.stats
+        : {};
+    const rawBindings = controlsFile.bindings && typeof controlsFile.bindings === 'object'
+        ? controlsFile.bindings
+        : {};
+    const controls = {};
+    for (const action of Object.keys(rawBindings).sort()) {
+        const value = rawBindings[action];
+        if (Array.isArray(value) && value.every((entry) => typeof entry === 'string')) {
+            controls[action] = value;
+        }
+    }
+    return {
+        archetype: typeof game.archetype === 'string' ? game.archetype : null,
+        scenes: await directFiles(path.join(projectPath, 'src/scenes'), '.scene.json'),
+        prefabs: prefabs.sort((a, b) => a.ref.localeCompare(b.ref)),
+        components: await directFiles(path.join(projectPath, 'src/components'), '.ts'),
+        roles: await directFiles(path.join(projectPath, 'src/roles'), '.ts'),
+        states: await directFiles(path.join(projectPath, 'src/states'), '.ts'),
+        ui: await directFiles(path.join(projectPath, 'src/ui'), '.html'),
+        stats: Object.keys(rawStats).sort(),
+        controls,
+        notes: check.notes,
+        provenance: [],
+        warnings: [],
+    };
+}

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/art.d.ts

@@ -0,0 +1,10 @@
+import type { ArchetypeArt } from '@waica/engine';
+/**
+ * The archetype's stock art, as pure data (no asset imports: node tooling
+ * like scripts/sync-scene.mjs imports this module directly).
+ *
+ * Demo projects materialize each sheet as a real file at `src/art/<file>`
+ * and reference that path; `uri` is the legacy registry key that in-package
+ * prefab defaults (and old projects) still use.
+ */
+export declare const PLATFORMER_ART: ArchetypeArt[];

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/art.js

@@ -0,0 +1,13 @@
+/**
+ * The archetype's stock art, as pure data (no asset imports: node tooling
+ * like scripts/sync-scene.mjs imports this module directly).
+ *
+ * Demo projects materialize each sheet as a real file at `src/art/<file>`
+ * and reference that path; `uri` is the legacy registry key that in-package
+ * prefab defaults (and old projects) still use.
+ */
+export const PLATFORMER_ART = [
+    { file: 'waica-dog.png', uri: 'waica:dog' },
+    { file: 'waica-coin.png', uri: 'waica:coin' },
+    { file: 'waica-slime.png', uri: 'waica:slime' },
+];

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/bundle.d.ts

@@ -0,0 +1,3 @@
+import type { ArchetypeBundle } from '@waica/engine';
+/** Role and state-code baseline installed for a platformer project. */
+export declare const PLATFORMER_BUNDLE: ArchetypeBundle;

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/bundle.js

@@ -0,0 +1,10 @@
+import { CHASER_ROLE, NPC_ROLE, PATROLLER_ROLE, PLAYER_ROLE, } from '@waica/behaviors';
+/** Role and state-code baseline installed for a platformer project. */
+export const PLATFORMER_BUNDLE = {
+    roles: {
+        player: PLAYER_ROLE,
+        patroller: PATROLLER_ROLE,
+        chaser: CHASER_ROLE,
+        npc: NPC_ROLE,
+    },
+};

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/controls.d.ts

@@ -0,0 +1,5 @@
+import type { InputBindings } from '@waica/engine';
+/** Platformer actions and the exact legacy keyboard defaults. */
+export declare const PLATFORMER_BINDINGS: Readonly<InputBindings>;
+/** Friendly labels shown by the editor's controls panel. */
+export declare const PLATFORMER_ACTION_LABELS: Readonly<Record<string, string>>;

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/controls.js

@@ -0,0 +1,12 @@
+/** Platformer actions and the exact legacy keyboard defaults. */
+export const PLATFORMER_BINDINGS = {
+    left: ['ArrowLeft', 'KeyA'],
+    right: ['ArrowRight', 'KeyD'],
+    jump: ['Space', 'ArrowUp', 'KeyW'],
+};
+/** Friendly labels shown by the editor's controls panel. */
+export const PLATFORMER_ACTION_LABELS = {
+    left: 'Move left',
+    right: 'Move right',
+    jump: 'Jump',
+};

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/index.d.ts

@@ -0,0 +1,38 @@
+import { Game, type Entity } from '@waica/engine';
+export { PLATFORMER_BUNDLE } from './bundle.js';
+export { PLATFORMER_ACTION_LABELS, PLATFORMER_BINDINGS } from './controls.js';
+export { PLATFORMER_SCENE, PLATFORMER_BLANK_SCENE, DOG_SPRITE } from './scene-default.js';
+export { PLATFORMER_PREFABS } from './prefabs.js';
+export { PLATFORMER_UI } from './ui.js';
+export { PLATFORMER_ART } from './art.js';
+export { PLATFORMER_REGISTRY, PLATFORMER_PALETTE, PLATFORMER_ART_URLS } from './registry.js';
+/** Browser-complete manifest exported by the package root. */
+export declare const ARCHETYPE: {
+    id: string;
+    label: string;
+    scene: import("@waica/engine").SceneJson;
+    blankScene: import("@waica/engine").SceneJson;
+    palette: import("@waica/engine").EntityTemplate[];
+    prefabs: Record<string, import("@waica/engine").PrefabJson>;
+    art: import("@waica/engine").ArchetypeArt[];
+    entityIcons: Readonly<Record<string, string>>;
+    bindings: Readonly<import("@waica/engine").InputBindings>;
+    actionLabels: Readonly<Record<string, string>>;
+    bundle: import("@waica/engine").ArchetypeBundle;
+    registry: import("@waica/engine").SceneRegistry;
+    artUrls: Record<string, string>;
+};
+export interface PlatformerSetup {
+    player: Entity;
+    /** Collected-coin counter, for the HUD and tests. */
+    score: {
+        coins: number;
+    };
+}
+/**
+ * Sets up the platformer archetype's base scene by loading the default
+ * scene (real projects load their own src/scenes/*.json). The scene's
+ * 'coin-counter' UI piece renders the counter; the returned score just
+ * tracks it.
+ */
+export declare function setupPlatformer(game: Game): PlatformerSetup;

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/index.js

@@ -0,0 +1,34 @@
+import { Game, loadScene, } from '@waica/engine';
+import { ARCHETYPE as DATA_ARCHETYPE } from './manifest.js';
+import { PLATFORMER_REGISTRY, PLATFORMER_ART_URLS } from './registry.js';
+import { PLATFORMER_SCENE } from './scene-default.js';
+export { PLATFORMER_BUNDLE } from './bundle.js';
+export { PLATFORMER_ACTION_LABELS, PLATFORMER_BINDINGS } from './controls.js';
+export { PLATFORMER_SCENE, PLATFORMER_BLANK_SCENE, DOG_SPRITE } from './scene-default.js';
+export { PLATFORMER_PREFABS } from './prefabs.js';
+export { PLATFORMER_UI } from './ui.js';
+export { PLATFORMER_ART } from './art.js';
+export { PLATFORMER_REGISTRY, PLATFORMER_PALETTE, PLATFORMER_ART_URLS } from './registry.js';
+/** Browser-complete manifest exported by the package root. */
+export const ARCHETYPE = {
+    ...DATA_ARCHETYPE,
+    registry: PLATFORMER_REGISTRY,
+    artUrls: PLATFORMER_ART_URLS,
+};
+/**
+ * Sets up the platformer archetype's base scene by loading the default
+ * scene (real projects load their own src/scenes/*.json). The scene's
+ * 'coin-counter' UI piece renders the counter; the returned score just
+ * tracks it.
+ */
+export function setupPlatformer(game) {
+    loadScene(game, PLATFORMER_SCENE, PLATFORMER_REGISTRY);
+    const score = { coins: 0 };
+    game.events.on('collect', (value) => {
+        score.coins += typeof value === 'number' ? value : 1;
+    });
+    const player = game.find('Player');
+    if (!player)
+        throw new Error('default scene has no Player');
+    return { player, score };
+}

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/manifest.d.ts

@@ -0,0 +1,15 @@
+/** Asset-import-free manifest for Node tooling. */
+export declare const ARCHETYPE: {
+    id: string;
+    label: string;
+    scene: import("@waica/engine").SceneJson;
+    blankScene: import("@waica/engine").SceneJson;
+    registry: import("@waica/engine").SceneRegistry;
+    palette: import("@waica/engine").EntityTemplate[];
+    prefabs: Record<string, import("@waica/engine").PrefabJson>;
+    art: import("@waica/engine").ArchetypeArt[];
+    entityIcons: Readonly<Record<string, string>>;
+    bindings: Readonly<import("@waica/engine").InputBindings>;
+    actionLabels: Readonly<Record<string, string>>;
+    bundle: import("@waica/engine").ArchetypeBundle;
+};

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/manifest.js

@@ -0,0 +1,26 @@
+import { PLATFORMER_ART } from './art.js';
+import { PLATFORMER_BUNDLE } from './bundle.js';
+import { PLATFORMER_ACTION_LABELS, PLATFORMER_BINDINGS } from './controls.js';
+import { PLATFORMER_PREFABS } from './prefabs.js';
+import { PLATFORMER_PALETTE, PLATFORMER_REGISTRY_DATA } from './registry-data.js';
+import { PLATFORMER_BLANK_SCENE, PLATFORMER_SCENE } from './scene-default.js';
+const PLATFORMER_ENTITY_ICONS = {
+    PlatformerMotor: '🐕',
+    Collectible: '🪙',
+    Hazard: '👾',
+};
+/** Asset-import-free manifest for Node tooling. */
+export const ARCHETYPE = {
+    id: 'platformer',
+    label: 'Platformer',
+    scene: PLATFORMER_SCENE,
+    blankScene: PLATFORMER_BLANK_SCENE,
+    registry: PLATFORMER_REGISTRY_DATA,
+    palette: PLATFORMER_PALETTE,
+    prefabs: PLATFORMER_PREFABS,
+    art: PLATFORMER_ART,
+    entityIcons: PLATFORMER_ENTITY_ICONS,
+    bindings: PLATFORMER_BINDINGS,
+    actionLabels: PLATFORMER_ACTION_LABELS,
+    bundle: PLATFORMER_BUNDLE,
+};

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/prefabs.d.ts

@@ -0,0 +1,7 @@
+import type { PrefabJson } from '@waica/engine';
+/**
+ * The archetype's reusable entity templates, keyed by ref ('characters/slime').
+ * Scenes reference these and override per-entity props; the palette derives
+ * its pieces from this catalog.
+ */
+export declare const PLATFORMER_PREFABS: Record<string, PrefabJson>;

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/prefabs.js

@@ -0,0 +1,97 @@
+import { PLAYER_STATE_GRAPH } from '@waica/behaviors';
+import { DOG_SPRITE } from './scene-default.js';
+/**
+ * The archetype's reusable entity templates, keyed by ref ('characters/slime').
+ * Scenes reference these and override per-entity props; the palette derives
+ * its pieces from this catalog.
+ */
+export const PLATFORMER_PREFABS = {
+    'characters/player': {
+        waicaPrefab: 1,
+        type: 'character',
+        components: [
+            { type: 'AnimatedSprite', props: DOG_SPRITE },
+            { type: 'PlatformerMotor' },
+            {
+                type: 'StateMachine',
+                props: {
+                    role: 'player',
+                    initial: PLAYER_STATE_GRAPH.initial,
+                    states: PLAYER_STATE_GRAPH.states,
+                },
+            },
+            { type: 'Hitbox', props: { width: 0.9, height: 0.95 } },
+            { type: 'Respawnable', props: { killY: -12 } },
+        ],
+    },
+    'characters/slime': {
+        waicaPrefab: 1,
+        type: 'character',
+        components: [
+            {
+                type: 'AnimatedSprite',
+                props: {
+                    texture: 'waica:slime',
+                    cols: 4,
+                    rows: 1,
+                    width: 1.1,
+                    height: 1.1,
+                    clips: { idle: { frames: [0, 1, 2, 3], fps: 6 } },
+                    initialClip: 'idle',
+                },
+            },
+            { type: 'Patrol', props: { distance: 2, speed: 2 } },
+            {
+                type: 'StateMachine',
+                props: {
+                    role: 'patroller',
+                    initial: 'walk',
+                    states: { walk: { clip: 'idle' } },
+                },
+            },
+            { type: 'Hitbox', props: { width: 0.9, height: 0.6 } },
+            { type: 'Hazard', props: { stompable: true, bounce: 10 } },
+        ],
+    },
+    'objects/coin': {
+        waicaPrefab: 1,
+        type: 'object',
+        components: [
+            {
+                type: 'AnimatedSprite',
+                props: {
+                    texture: 'waica:coin',
+                    cols: 4,
+                    rows: 1,
+                    width: 0.6,
+                    height: 0.6,
+                    clips: { spin: { frames: [0, 1, 2, 3], fps: 8 } },
+                    initialClip: 'spin',
+                },
+            },
+            { type: 'Hitbox', props: { width: 0.5, height: 0.5 } },
+            { type: 'Collectible', props: { value: 1 } },
+        ],
+    },
+    'tiles/platform': {
+        waicaPrefab: 1,
+        type: 'tile',
+        components: [
+            { type: 'Sprite', props: { width: 3, height: 0.5, color: 0x2a9d8f } },
+            { type: 'Solid', props: { width: 3, height: 0.5 } },
+        ],
+    },
+    'tiles/block': {
+        waicaPrefab: 1,
+        type: 'tile',
+        components: [
+            { type: 'Sprite', props: { width: 2, height: 2, color: 0x264653 } },
+            { type: 'Solid', props: { width: 2, height: 2 } },
+        ],
+    },
+    'tiles/decor': {
+        waicaPrefab: 1,
+        type: 'tile',
+        components: [{ type: 'Sprite', props: { width: 1, height: 1, color: 0x8ecae6 } }],
+    },
+};

package/dist/mcp/node_modules/@waica/archetype-platformer/dist/registry-data.d.ts

@@ -0,0 +1,5 @@
+import { type EntityTemplate, type SceneRegistry } from '@waica/engine';
+/** Asset-import-free registry. Browser URL resolution is layered on separately. */
+export declare const PLATFORMER_REGISTRY_DATA: SceneRegistry;
+/** The editor palette: pieces you can drag into the viewport, one per prefab. */
+export declare const PLATFORMER_PALETTE: EntityTemplate[];