castle-web-cli 0.4.81 → 0.4.82

package/kits/basic-2d/CLAUDE.md

@@ -100,13 +100,14 @@ This inline shape is fine to keep writing by hand — see `## Blueprints` for wh
 Every actor placed through the editor is an **instance** of a **blueprint**: a `.scene` file under `blueprints/` whose single actor (`actors[0]`, no `id`) is the template. An instance actor looks like:
 
 ```json
-{ "id": "abc123", "blueprint": "blueprints/blueprint-1.scene", "components": { "Layout": { "x": 100, "y": 200 } } }
+{ "id": "abc123", "blueprint": "blueprints/enemy.scene", "components": { "Layout": { "x": 100, "y": 200 } } }
 ```
 
 `components` on an instance holds ONLY the props that differ from the blueprint (an override), merged on top of the blueprint's template per-property. Editing the blueprint file changes every instance that doesn't override that prop; editing an instance's own `Layout.x`/`y`/`rotation` never touches the blueprint (position/rotation are always instance-local — see `Layout.jsx`'s `propertyMeta`). This is entirely optional for you to manage directly:
 
 - **Plain inline actors (no `blueprint` field) still just work.** Write them the normal way; the editor mints a blueprint for each one automatically the first time a human opens that scene in the browser, and rewrites the actor into an instance. You never have to do this migration yourself.
 - **Reference a blueprint directly when it saves real duplication** — e.g. 10 identical enemy actors: write one `blueprints/enemy.scene` (`{ "name": "Enemy", "actors": [{ "components": { "Sprite": {...}, "Collider": {...}, "Enemy": {...} } }] }`) and 10 scene actors that each just set `"blueprint": "blueprints/enemy.scene"` plus their own `Layout.x`/`y`. Don't bother doing this for a one-off actor — plain inline is simpler and migrates fine later.
+- **When an actor is a distinct kind of thing** (not a one-off), author its blueprint yourself — `blueprints/<meaningful>.scene` with a real `"name"` — instead of leaving it inline for auto-migration to name; migration derives a reasonable name/file from the actor's `id` when it can, but a blueprint you write intentionally will always be clearer than one it infers.
 - Never invent your own `blueprint` path pointing at a file you didn't also create — a dangling reference resolves to "no template" (the instance's own sparse `components` render alone, missing whatever it expected to inherit).
 
 ## Built-in behaviors

package/kits/basic-2d/engine/ScenePlayer.jsx

@@ -54,7 +54,11 @@ export function ScenePlayer({ sceneData, sprites, files, behaviorClasses, onFirs
     canvas.addEventListener('pointermove', onPointerMove);
     canvas.addEventListener('pointerup', onPointerUp);
     canvas.addEventListener('pointercancel', onPointerUp);
-    canvas.focus();
+    // Don't steal focus from the embedding shell (e.g. the chat composer) on
+    // reload/remount. A real standalone/top-level play, or an iframe that's
+    // already focused, still auto-focuses; a click into the game always
+    // focuses via onPointerDown above.
+    if (document.hasFocus() || window.parent === window) canvas.focus();
     const stopLoop = startPlayerLoop(canvas, ctx, runtime, onFirstFrame);
     return () => {
       stopLoop();

package/kits/basic-2d/engine/blueprint.js

@@ -126,6 +126,69 @@ function mintBlueprintPath(existingPaths) {
   return `${BLUEPRINTS_DIR}/blueprint-${max + 1}.scene`;
 }
 
+// "auto-tetris" -> "Auto Tetris". Splits on non-alphanumeric runs (covers the
+// hyphen/underscore ids actors typically use) and title-cases each word.
+function humanizeActorId(id) {
+  return id
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((word) => word[0].toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+// "Auto Tetris" -> "auto-tetris" for the filename slug. Kept independent of
+// the actor id's own formatting (an id could already be any casing/shape).
+function slugifyActorId(id) {
+  return id
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+// Derive a migration blueprint's { name, path } from the orphan actor's own
+// `id` -- the one meaningful signal available at migration time (vs. the
+// anonymous "Blueprint N" counter), so e.g. an actor `id: "logo"` mints
+// `blueprints/logo.scene` named "Logo" instead of "Blueprint 1". Returns null
+// when the id doesn't yield a usable name/slug, so the caller falls back to
+// the counter-based mint functions.
+//
+// Collision safety is load-bearing: `knownBlueprints` includes every
+// already-migrated blueprint in this same run (see the caller's loop), so two
+// orphan actors that humanize to the same name, or that collide with a
+// pre-existing blueprint, must never mint the same path or duplicate name.
+// Deterministically disambiguate with a numeric suffix instead.
+function deriveBlueprintName(actorId, knownBlueprints) {
+  if (typeof actorId !== 'string') return null;
+  const baseSlug = slugifyActorId(actorId);
+  const baseName = humanizeActorId(actorId.trim());
+  if (!baseSlug || !baseName) return null;
+  const existingNames = new Set(knownBlueprints.map((blueprint) => blueprint.name));
+  const existingPaths = new Set(knownBlueprints.map((blueprint) => blueprint.path));
+  const MAX_ATTEMPTS = 1000;
+  for (let suffix = 1; suffix <= MAX_ATTEMPTS; suffix += 1) {
+    const name = suffix === 1 ? baseName : `${baseName} ${suffix}`;
+    const path = suffix === 1 ? `${BLUEPRINTS_DIR}/${baseSlug}.scene` : `${BLUEPRINTS_DIR}/${baseSlug}-${suffix}.scene`;
+    if (!existingNames.has(name) && !existingPaths.has(path)) return { name, path };
+  }
+  // Pathological: 1000 colliding suffixes. Let the caller fall back to the
+  // counter-based mint functions rather than looping forever.
+  return null;
+}
+
+// { name, path } for a freshly minted migration blueprint: the actor id's
+// derived name/slug when usable and collision-free, else the anonymous
+// counter (see `deriveBlueprintName`). Factored out so the branching here
+// doesn't add to `migrateOrphanActors`'s own complexity.
+function mintMigrationBlueprintName(actorId, knownBlueprints) {
+  const derived = deriveBlueprintName(actorId, knownBlueprints);
+  if (derived) return derived;
+  return {
+    name: mintBlueprintName(knownBlueprints.map((blueprint) => blueprint.name)),
+    path: mintBlueprintPath(knownBlueprints.map((blueprint) => blueprint.path)),
+  };
+}
+
 export function formatBlueprintFileText(name, components) {
   return formatJson({ name, actors: [{ components }] });
 }
@@ -408,11 +471,19 @@ export function migrateOrphanActors(files, behaviors, sceneData) {
       if (!props) continue;
       const Behavior = findBehavior(behaviors, behaviorName);
       const { inherited, overridden } = splitByInherit(Behavior, props);
-      if (Object.keys(inherited).length > 0) templateComponents[behaviorName] = inherited;
+      // A behavior attached with no props at all (e.g. `AutoTetris: {}`) has
+      // both `inherited` and `overridden` empty. It must still land somewhere,
+      // or the attachment itself -- not just some prop of it -- silently
+      // vanishes from the resolved actor. Fall back to the template side (as
+      // `{}`) so the instance keeps referencing the behavior exactly once.
+      if (Object.keys(inherited).length > 0 || Object.keys(overridden).length === 0) {
+        templateComponents[behaviorName] = inherited;
+      }
       if (Object.keys(overridden).length > 0) instanceOverrides[behaviorName] = overridden;
     }
-    const name = mintBlueprintName(knownBlueprints.map((blueprint) => blueprint.name));
-    const path = mintBlueprintPath(knownBlueprints.map((blueprint) => blueprint.path));
+    // The actor's own id is the one meaningful signal available here (vs. an
+    // anonymous "Blueprint N") -- see `mintMigrationBlueprintName`.
+    const { name, path } = mintMigrationBlueprintName(actor.id, knownBlueprints);
     const text = formatBlueprintFileText(name, templateComponents);
     newBlueprintFiles.push({ path, text });
     knownBlueprints = [...knownBlueprints, { path, name, components: templateComponents }];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.81",
+  "version": "0.4.82",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"

package/kits/basic-2d/pnpm-workspace.yaml

@@ -1,3 +0,0 @@
-allowBuilds:
-  '@fortawesome/fontawesome-common-types': set this to true or false
-  '@fortawesome/free-solid-svg-icons': set this to true or false