@waica/cli 0.4.1 → 0.5.0

package/dist/mcp/node_modules/@waica/engine/dist/authoring-defaults.js

@@ -0,0 +1,51 @@
+const EXCLUDED_KEYS = new Set(['entity', 'game']);
+function isSerializable(value) {
+    if (value === null)
+        return true;
+    const kind = typeof value;
+    if (kind === 'string' || kind === 'number' || kind === 'boolean')
+        return true;
+    if (kind !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return true;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * The public authoring surface of a component class: own enumerable fields
+ * plus setter-backed accessors (walking the whole prototype chain, so a
+ * getter/setter pair inherited from a base class counts), read through the
+ * getter so the value is the public one. Excludes `_`-prefixed keys, the
+ * base Component wiring (`entity`, `game`), anything the class (or an
+ * ancestor) declares `transient`, and values that are `undefined` or not
+ * JSON-serializable (`Map`, `Set`, functions, class instances).
+ */
+export function authoringDefaults(Class, onError) {
+    let instance;
+    try {
+        instance = new Class();
+    }
+    catch (error) {
+        onError?.(error);
+        return {};
+    }
+    const transient = new Set(Class.transient ?? []);
+    const keys = new Set(Object.keys(instance));
+    for (let proto = Object.getPrototypeOf(instance); proto && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+            if (descriptor.set)
+                keys.add(key);
+        }
+    }
+    const result = {};
+    for (const key of keys) {
+        if (EXCLUDED_KEYS.has(key) || key.startsWith('_') || transient.has(key))
+            continue;
+        const value = instance[key];
+        if (value === undefined || !isSerializable(value))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}

package/dist/mcp/node_modules/@waica/engine/dist/component.d.ts

@@ -7,8 +7,10 @@ export interface ParamSpec {
     min?: number;
     max?: number;
     step?: number;
-    /** Allowed values for a string param; rendered as a dropdown. */
+    /** Allowed values for a string param; rendered as a dropdown. Takes precedence over ref. */
     options?: string[];
+    /** Project value this string param names; rendered and validated as a typed reference. */
+    ref?: 'prefab' | 'stat' | 'action' | 'clip';
 }
 export interface ComponentClass<T extends Component = Component> {
     new (): T;
@@ -21,6 +23,12 @@ export interface ComponentClass<T extends Component = Component> {
     displayName?: string;
     /** Which properties the inspector exposes, with their ranges. */
     params?: Record<string, ParamSpec>;
+    /**
+     * Instance fields holding runtime state rather than authorable defaults.
+     * Excluded from authoringDefaults(); a subclass that does not redeclare
+     * this inherits its base's list.
+     */
+    transient?: readonly string[];
 }
 /** Cardinal unit normal pointing away from the contacted Solid surface. */
 export interface ContactNormal {
@@ -43,6 +51,7 @@ export declare abstract class Component {
     static componentName: string;
     static displayName?: string;
     static params?: Record<string, ParamSpec>;
+    static transient?: readonly string[];
     entity: Entity;
     game: Game;
     /** Runs once the component is mounted on its entity. */

package/dist/mcp/node_modules/@waica/engine/dist/component.js

@@ -6,6 +6,7 @@ export class Component {
     static componentName = 'Component';
     static displayName;
     static params;
+    static transient;
     entity;
     game;
 }

package/dist/mcp/node_modules/@waica/engine/dist/components/animated-sprite.d.ts

@@ -26,6 +26,7 @@ export declare class AnimatedSprite extends Component {
             step: number;
         };
     };
+    static transient: string[];
     /** Spritesheet URL. */
     texture: string;
     /** Sheet grid dimensions. */

package/dist/mcp/node_modules/@waica/engine/dist/components/animated-sprite.js

@@ -19,6 +19,16 @@ export class AnimatedSprite extends Component {
         offsetY: { label: 'y offset' },
         layer: { label: 'layer', min: -5, max: 5, step: 1 },
     };
+    static transient = [
+        'current',
+        'player',
+        'sheets',
+        'texs',
+        'mesh',
+        'frame',
+        'frameScaleX',
+        'frameScaleY',
+    ];
     /** Spritesheet URL. */
     texture = '';
     /** Sheet grid dimensions. */

package/dist/mcp/node_modules/@waica/engine/dist/components/sprite.d.ts

@@ -20,6 +20,7 @@ export declare class Sprite extends Component {
             step: number;
         };
     };
+    static transient: string[];
     private _width;
     private _height;
     get width(): number;

package/dist/mcp/node_modules/@waica/engine/dist/components/sprite.js

@@ -12,6 +12,7 @@ export class Sprite extends Component {
         offsetY: { label: 'y offset' },
         layer: { label: 'layer', min: -5, max: 5, step: 1 },
     };
+    static transient = ['mesh'];
     // Size, color and offset are reactive so inspector edits update the live quad.
     // Texture still needs a rebuild. TODO(H1): fully reactive props.
     _width = 1;

package/dist/mcp/node_modules/@waica/engine/dist/index.d.ts

@@ -4,6 +4,7 @@ export { CAMERA_DEFAULTS, resolveSceneCamera, stepSceneCamera } from './camera.j
 export type { SceneCameraJson, CameraLimitsJson, ResolvedSceneCamera } from './camera.js';
 export { Entity } from './entity.js';
 export { Component } from './component.js';
+export { authoringDefaults } from './authoring-defaults.js';
 export type { ComponentClass, ContactNormal, ParamSpec, SolidContact, } from './component.js';
 export { collectModuleComponents, mergeRegistryComponents } from './component-registry.js';
 export type { ComponentModule } from './component-registry.js';

package/dist/mcp/node_modules/@waica/engine/dist/index.js

@@ -2,6 +2,7 @@ export { Game } from './game.js';
 export { CAMERA_DEFAULTS, resolveSceneCamera, stepSceneCamera } from './camera.js';
 export { Entity } from './entity.js';
 export { Component } from './component.js';
+export { authoringDefaults } from './authoring-defaults.js';
 export { collectModuleComponents, mergeRegistryComponents } from './component-registry.js';
 export { Input, DEFAULT_BINDINGS } from './input.js';
 export { Stats } from './stats.js';

package/dist/mcp/node_modules/@waica/engine/dist/state/state-machine.d.ts

@@ -13,7 +13,7 @@ export interface StateTransitionJson {
  * transitions instead of a real state.
  */
 export interface StateJson {
-    /** Clip to play on enter; defaults to the state's own name. */
+    /** Clip reference resolved against the sibling AnimatedSprite; defaults to the state's name. */
     clip?: string;
     transitions?: StateTransitionJson[];
 }
@@ -53,6 +53,7 @@ export declare class StateMachine extends Component {
             label: string;
         };
     };
+    static transient: string[];
     /** The character's role — names the logic set providing its state code. */
     role: string;
     /** Starting state; defaults to the first declared state. */

package/dist/mcp/node_modules/@waica/engine/dist/state/state-machine.js

@@ -47,6 +47,7 @@ export class StateMachine extends Component {
     static params = {
         role: { label: 'Role' },
     };
+    static transient = ['current', 'elapsed', 'instanceHooks', 'signals', 'warnedClips'];
     /** The character's role — names the logic set providing its state code. */
     role = '';
     /** Starting state; defaults to the first declared state. */
@@ -96,7 +97,12 @@ export class StateMachine extends Component {
         // capped so a degenerate cyclic graph can't hang the loop.
         for (let hops = 0; hops < 8; hops++) {
             const edge = nextTransition(this.states, this.current, this.env());
-            if (!edge)
+            // A '*' edge is re-merged against whatever state the loop just
+            // entered, so a still-queued signal (signals.clear() only runs after
+            // this loop) keeps firing every remaining hop. Without this guard
+            // that replays onExit/onEnter on the state hops already settled into
+            // — goto() has the same guard for the same reason.
+            if (!edge || edge.to === this.current)
                 break;
             // A transition fired by a key press spends it: one press, one
             // transition — it can't fire again from the state just entered.

package/dist/mcp/node_modules/@waica/engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waica/engine",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Waica game engine core — archetype-driven, web-first, 2D & 3D",
   "license": "MIT",
   "type": "module",

package/dist/mcp/package-resolver.js

@@ -15,12 +15,18 @@ export class PackageUnavailableError extends Error {
 const BUNDLED_SPECIFIERS = new Set([
     '@waica/engine',
     '@waica/behaviors',
+    '@waica/archetype-platformer',
     '@waica/archetype-platformer/manifest',
 ]);
 const requireBundled = createRequire(import.meta.url);
+/** Node resolution anchored at a game project rather than the MCP host process. */
+export function projectAnchoredRequire(projectPath) {
+    return createRequire(path.join(projectPath, 'package.json'));
+}
 const BUILT_ENTRY_BY_SPECIFIER = {
     '@waica/engine': 'dist/index.js',
     '@waica/behaviors': 'dist/index.js',
+    '@waica/archetype-platformer': 'dist/index.js',
     '@waica/archetype-platformer/manifest': 'dist/manifest.js',
 };
 function specifierFor(packageName, subpath) {
@@ -117,13 +123,15 @@ async function loadBundledModule(specifier, packageRoot) {
             return import('@waica/engine');
         case '@waica/behaviors':
             return import('@waica/behaviors');
+        case '@waica/archetype-platformer':
+            return import('@waica/archetype-platformer');
         case '@waica/archetype-platformer/manifest':
             return import('@waica/archetype-platformer/manifest');
         default:
             throw new PackageUnavailableError(specifier);
     }
 }
-function causeText(error) {
+export function causeText(error) {
     if (!(error instanceof Error))
         return String(error);
     const code = error.code;
@@ -150,7 +158,7 @@ export class PackageResolver {
     constructor(projectPath) {
         this.projectPath = projectPath;
         if (projectPath) {
-            this.projectRequire = createRequire(path.join(projectPath, 'package.json'));
+            this.projectRequire = projectAnchoredRequire(projectPath);
             this.projectManifestUsable = projectPackageJsonUsable(projectPath);
         }
     }

package/dist/mcp/project-component-loader.js

@@ -0,0 +1,287 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodeModule from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { classDefaults, objectRecord } from './component-metadata.js';
+import { causeText, PackageResolver, projectAnchoredRequire } from './package-resolver.js';
+import { directFiles } from './project-path.js';
+const { createRequire } = nodeModule;
+// Two independent identifiers travel on every module URL this loader hands
+// out: PROJECT_PARAM routes a resolve-hook call back to the validation run
+// that started it (an ephemeral, in-memory lookup, cleaned up per run), and
+// LOAD_PARAM is a content hash that only changes when the file's own bytes
+// change. Splitting them is what lets re-validating unchanged files reuse
+// Node's module cache instead of pinning a fresh entry on every run (see
+// loadProjectComponents below).
+const PROJECT_PARAM = 'waica-component-project';
+const LOAD_PARAM = 'waica-component-load';
+const hookContexts = new Map();
+// Loading this tiny CommonJS trampoline through Node keeps Vitest from
+// rewriting fixture imports. The build copies the same file byte-for-byte.
+const nativeImport = createRequire(import.meta.url)('./native-import.cjs');
+const MODULE_HOOKS_MIN_NODE = '22.15';
+/** Pure so it can be exercised directly, independent of the running Node. */
+export function nodeSupportsModuleHooks(moduleApi = nodeModule) {
+    return typeof moduleApi.registerHooks === 'function';
+}
+/**
+ * `node:module`'s `registerHooks` landed in Node 22.15; this MCP server is
+ * still expected to start (and serve every other tool) on the older Node
+ * hosts an agent may be running. A static named import of `registerHooks`
+ * would fail ESM linking on those hosts before the transport ever connects
+ * (see workspace-runtime.ts for the same guard on the same API), so this is
+ * a namespace import feature-checked at runtime instead.
+ */
+const hooksSupported = nodeSupportsModuleHooks();
+/** The single finding emitted in place of real component loading on a host too old for module hooks. */
+export function unsupportedNodeFailure(nodeVersion = process.version) {
+    return {
+        code: 'component-load-unsupported',
+        file: 'src',
+        message: `Deep component validation requires Node >= ${MODULE_HOOKS_MIN_NODE} (node:module registerHooks) ` +
+            `to run project components, roles and states in-process; this host runs Node ${nodeVersion}. ` +
+            'Skipping in-process module loading: component params and instance defaults from project code ' +
+            'will not appear in validate_project or list_components until the host upgrades.',
+    };
+}
+function runFromParent(parentURL) {
+    if (!parentURL)
+        return undefined;
+    try {
+        const token = new URL(parentURL).searchParams.get(PROJECT_PARAM);
+        const context = token ? hookContexts.get(token) : undefined;
+        return token && context ? { token, context } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function versioned(url, token, content) {
+    url.searchParams.set(PROJECT_PARAM, token);
+    url.searchParams.set(LOAD_PARAM, content);
+    return url.href;
+}
+function projectToken(projectPath) {
+    return createHash('sha1').update(path.resolve(projectPath)).digest('hex').slice(0, 16);
+}
+/** Content identity for cache-busting: stable across runs, changes only when the file's bytes do. */
+function contentToken(filePath) {
+    try {
+        return createHash('sha1').update(readFileSync(filePath)).digest('hex').slice(0, 16);
+    }
+    catch {
+        // The subsequent import attempt reports the real read/import error; this
+        // token only needs to exist so versioned() has something to stamp.
+        return 'unreadable';
+    }
+}
+const RELATIVE_EXTENSIONS = ['.ts', '.tsx', '.js'];
+/** Mirrors the editor's resolveProjectImport (play-code.ts): direct, direct+ext, direct/index+ext. */
+function relativeCandidates(unresolvedPath) {
+    const candidates = [
+        ...RELATIVE_EXTENSIONS.map((extension) => `${unresolvedPath}${extension}`),
+        ...RELATIVE_EXTENSIONS.map((extension) => path.join(unresolvedPath, `index${extension}`)),
+    ];
+    if (unresolvedPath.endsWith('.js')) {
+        const withoutJs = unresolvedPath.slice(0, -'.js'.length);
+        candidates.unshift(`${withoutJs}.ts`, `${withoutJs}.tsx`);
+    }
+    return candidates;
+}
+function resolveRelativeCandidate(unresolvedPath) {
+    return relativeCandidates(unresolvedPath).find((candidate) => existsSync(candidate));
+}
+// The synchronous hook is process-wide, but it is inert for imports that were
+// not initiated by this loader. The PROJECT_PARAM token selects the project
+// resolver for a given run; nextResolve is always tried first so real Node
+// resolution (package "exports" maps, symlinks, literal existing paths) stays
+// authoritative, and our TypeScript-project conventions are only a fallback.
+if (hooksSupported) {
+    nodeModule.registerHooks({
+        resolve(specifier, context, nextResolve) {
+            const run = runFromParent(context.parentURL);
+            if (!run)
+                return nextResolve(specifier, context);
+            if (specifier.startsWith('@waica/')) {
+                const bridge = run.context.packageBridges.get(specifier);
+                if (bridge)
+                    return { url: bridge, shortCircuit: true };
+                const resolved = run.context.projectRequire.resolve(specifier);
+                const url = pathToFileURL(resolved);
+                return {
+                    url: /\.tsx?$/.test(resolved)
+                        ? versioned(url, run.token, contentToken(resolved))
+                        : url.href,
+                    shortCircuit: true,
+                };
+            }
+            if (specifier.startsWith('.')) {
+                const unresolved = new URL(specifier, context.parentURL);
+                let resolvedURL;
+                try {
+                    resolvedURL = new URL(nextResolve(specifier, context).url);
+                }
+                catch (error) {
+                    // Directory imports (./lib -> ./lib/index.ts) and multi-dot
+                    // specifiers (./foo.helper -> ./foo.helper.ts) are valid under the
+                    // project's moduleResolution "bundler" and run fine in Vite, but
+                    // Node's default resolver rejects both — fall back to the same
+                    // candidates the editor tries before giving up.
+                    const fallback = resolveRelativeCandidate(fileURLToPath(unresolved));
+                    if (!fallback)
+                        throw error;
+                    resolvedURL = pathToFileURL(fallback);
+                }
+                const resolvedPath = fileURLToPath(resolvedURL);
+                return {
+                    url: versioned(resolvedURL, run.token, contentToken(resolvedPath)),
+                    shortCircuit: true,
+                };
+            }
+            return nextResolve(specifier, context);
+        },
+    });
+}
+function componentDescriptions(module, file) {
+    const descriptions = {};
+    for (const value of Object.values(module)) {
+        if (typeof value !== 'function' || !Object.hasOwn(value, 'componentName'))
+            continue;
+        const Class = value;
+        if (typeof Class.componentName !== 'string' || !Class.componentName)
+            continue;
+        descriptions[Class.componentName] = {
+            file,
+            params: objectRecord(Class.params),
+            defaults: classDefaults(Class),
+        };
+    }
+    return descriptions;
+}
+function errorChain(error) {
+    const errors = [];
+    let current = error;
+    const seen = new Set();
+    while (current instanceof Error && !seen.has(current)) {
+        errors.push(current);
+        seen.add(current);
+        current = current.cause;
+    }
+    return errors;
+}
+function unsupportedByNode(error) {
+    for (const candidate of errorChain(error)) {
+        const code = candidate.code;
+        if (code === 'ERR_UNKNOWN_FILE_EXTENSION' ||
+            code === 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX') {
+            return true;
+        }
+        if (/not supported in strip-only mode|unsupported TypeScript syntax|unknown file extension/i.test(candidate.message)) {
+            return true;
+        }
+    }
+    return false;
+}
+function bridgeModule(token, specifier, module) {
+    const key = `waica.project-component.${process.pid}.${token}.${specifier}`;
+    Reflect.set(process, Symbol.for(key), module);
+    const exports = Object.keys(module).filter((name) => /^[$A-Z_a-z][$\w]*$/.test(name));
+    const lines = [
+        `const value = process[Symbol.for(${JSON.stringify(key)})]`,
+        `if (!value) throw new Error(${JSON.stringify(`Missing package bridge for ${specifier}`)})`,
+    ];
+    let index = 0;
+    for (const name of exports) {
+        if (name === 'default') {
+            lines.push('export default value.default');
+            continue;
+        }
+        const binding = `binding${index++}`;
+        lines.push(`const ${binding} = value[${JSON.stringify(name)}]`, `export { ${binding} as ${name} }`);
+    }
+    return {
+        key,
+        url: `data:text/javascript;charset=utf-8,${encodeURIComponent(lines.join('\n'))}`,
+    };
+}
+const BRIDGED_SPECIFIERS = ['@waica/engine', '@waica/behaviors', '@waica/archetype-platformer'];
+async function packageBridges(projectPath, token, 
+// Defaults to a fresh resolver for standalone callers (e.g. tests); the
+// real loadProjectComponents call site reuses validateProject's resolver
+// so these packages are not re-resolved from scratch a second time.
+resolver = new PackageResolver(projectPath)) {
+    // @waica/archetype-platformer joins engine/behaviors here (not just the
+    // separate projectRequire.resolve path below) so a freshly created,
+    // not-yet-installed project still gets the MCP-bundled copy the same way
+    // it already does for engine/behaviors, instead of a bare MODULE_NOT_FOUND.
+    // The three packages are independent, so they load concurrently.
+    const bridges = await Promise.all(BRIDGED_SPECIFIERS.map(async (specifier) => {
+        try {
+            const loaded = await resolver.load(specifier);
+            // Keyed by the resolved package's own version rather than a per-run
+            // counter, so re-validating without a dependency bump reuses the exact
+            // same data: URL — and therefore Node's already-cached module for it —
+            // instead of pinning a fresh, functionally identical one every run.
+            const bridge = bridgeModule(`${token}:${loaded.provenance.version}`, specifier, loaded.module);
+            return { specifier, bridge };
+        }
+        catch {
+            // The importing project file receives the anchored resolver's real error.
+            return undefined;
+        }
+    }));
+    const urls = new Map();
+    const keys = [];
+    for (const entry of bridges) {
+        if (!entry)
+            continue;
+        urls.set(entry.specifier, entry.bridge.url);
+        keys.push(entry.bridge.key);
+    }
+    return { urls, keys };
+}
+async function projectModuleFiles(projectPath) {
+    const groups = await Promise.all(['components', 'roles', 'states'].map(async (directory) => (await directFiles(path.join(projectPath, 'src', directory), '.ts')).map((file) => `src/${directory}/${file}`)));
+    return groups.flat();
+}
+/**
+ * Executes every project-owned component/role/state module independently.
+ * Failures are returned as data so one bad file cannot abort validation.
+ */
+export async function loadProjectComponents(projectPath, resolver) {
+    if (!hooksSupported) {
+        return { components: {}, failures: [unsupportedNodeFailure()] };
+    }
+    const token = projectToken(projectPath);
+    const bridges = await packageBridges(projectPath, token, resolver);
+    hookContexts.set(token, {
+        projectRequire: projectAnchoredRequire(projectPath),
+        packageBridges: bridges.urls,
+    });
+    const components = {};
+    const failures = [];
+    try {
+        for (const relative of await projectModuleFiles(projectPath)) {
+            const file = path.join(projectPath, relative);
+            try {
+                const entryHref = versioned(pathToFileURL(file), token, contentToken(file));
+                const module = await nativeImport(entryHref);
+                Object.assign(components, componentDescriptions(module, relative));
+            }
+            catch (error) {
+                failures.push({
+                    code: unsupportedByNode(error) ? 'component-load-unsupported' : 'component-load-failed',
+                    file: relative,
+                    message: causeText(error),
+                });
+            }
+        }
+    }
+    finally {
+        hookContexts.delete(token);
+        for (const key of bridges.keys)
+            Reflect.deleteProperty(process, Symbol.for(key));
+    }
+    return { components, failures };
+}

package/dist/mcp/server.js

@@ -1,3 +1,6 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { createProject } from './create-project.js';
@@ -197,8 +200,35 @@ function errorResult(error, args) {
         provenance: [],
     }, true);
 }
+/**
+ * The version reported over MCP: whatever artifact is shipping this server.
+ * In a checkout that is packages/mcp; once the CLI vendors the build into
+ * dist/mcp it is the CLI itself. Walking up to the nearest package.json finds
+ * the right one in both layouts, and every package in this repo moves on one
+ * version, so the host is told the release it is actually running instead of
+ * a number frozen in this file — which is how it reported 0.1.0 through the
+ * 0.4.x releases.
+ */
+function shippedVersion() {
+    let directory = path.dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        const manifest = path.join(directory, 'package.json');
+        if (existsSync(manifest)) {
+            const { version } = JSON.parse(readFileSync(manifest, 'utf8'));
+            if (version)
+                return version;
+        }
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            return '0.0.0';
+        directory = parent;
+    }
+}
 export function createWaicaMcpServer() {
-    const server = new Server({ name: '@waica/mcp', version: '0.1.0' }, {
+    const server = new Server(
+    // The name stays fixed: it identifies the server to the host, not the
+    // package that happens to carry it.
+    { name: '@waica/mcp', version: shippedVersion() }, {
         capabilities: { tools: {} },
         instructions: 'Operate on user Waica projects through absolute project_path values. Keep editing JSON and TypeScript with the host file tools.',
     });

package/dist/mcp/stdio.js

@@ -1,11 +1,36 @@
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { prepareWorkspaceRuntime } from './workspace-runtime.js';
+/**
+ * Logs to stderr (never stdout — that's the JSON-RPC transport) instead of
+ * letting the failure reach Node's default handling. Exported so the logging
+ * itself is unit-testable without touching the global process listeners.
+ */
+export function reportProjectCodeFailure(kind, detail) {
+    console.error(`waica-mcp: ${kind} — likely async work scheduled by a project module executed during ` +
+        'validate_project (e.g. a floating fetch() or a throwing setTimeout callback). ' +
+        'The server keeps running:', detail);
+}
+/**
+ * validate_project runs project-owned components/roles/states in-process
+ * (project-component-loader.ts). That code can schedule async work that
+ * rejects or throws *after* module evaluation already returned — Node's
+ * default handling for that is to crash the whole process, which would take
+ * down this long-lived stdio server and every other in-flight tool call for
+ * one module's sloppy code. A subprocess sandbox for project code is a
+ * larger, separately tracked follow-up; this keeps the blast radius to a
+ * logged line for now.
+ */
+function installProjectCodeGuards() {
+    process.on('unhandledRejection', (reason) => reportProjectCodeFailure('unhandledRejection', reason));
+    process.on('uncaughtException', (error) => reportProjectCodeFailure('uncaughtException', error));
+}
 /**
  * Connects the MCP server to stdio. Kept separate from the bin wrapper so the
  * waica CLI can start the same server in-process from its bundled copy without
  * importing a module that runs on load.
  */
 export async function startStdioServer() {
+    installProjectCodeGuards();
     await prepareWorkspaceRuntime();
     const { createWaicaMcpServer } = await import('./server.js');
     const server = createWaicaMcpServer();

package/dist/mcp/template/src/characters/player.character.json

@@ -112,6 +112,23 @@
                 "to": "idle"
               }
             ]
+          },
+          "dead": {
+            "clip": "idle",
+            "transitions": [
+              {
+                "on": "timer:0.8",
+                "to": "idle"
+              }
+            ]
+          },
+          "*": {
+            "transitions": [
+              {
+                "on": "signal:death",
+                "to": "dead"
+              }
+            ]
           }
         }
       }
@@ -124,9 +141,19 @@
       }
     },
     {
-      "type": "Respawnable",
+      "type": "Respawnable"
+    },
+    {
+      "type": "Health",
+      "props": {
+        "max": 3,
+        "invulnerability": 1
+      }
+    },
+    {
+      "type": "OutOfBounds",
       "props": {
-        "killY": -12
+        "minY": -12
       }
     }
   ]