Add ESLint and Prettier, and close the node test gaps

Tooling:
- Prettier as the single formatting authority (110 columns, single quotes,
  measured against the existing style); Markdown excluded because table-cell
  padding turns the README glossary into 1000-character lines.
- Type-aware ESLint ending in eslint-config-prettier, so a rule always means
  "this is a bug", never "this looks different".
- .editorconfig and an `npm run check` that runs typecheck, lint, format and
  tests in one go.

Findings fixed on the first run: three more duplicate imports, four
String(unknown) calls (parameter types narrowed instead of casts), two dead
initialisers, two redundant casts, a console.log for a real error. Two
warnings were false here and are disabled with a reason in place.

Tests 132 -> 269:
- node-catalog.test.ts covers every node with a run(), with a guard that fails
  when a new node has no row.
- behavior-events.test.ts covers the ten event nodes through a running World,
  checking timing rather than existence.
- Input's state machine (press/release/releaseAll) is reachable without DOM
  events now; the DOM handlers are thin adapters.

Compare fell back to == without a configured operator although the schema
default is <; aligned.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/core/model/Asset.ts

@@ -65,7 +65,8 @@ export interface ContainerAsset extends AssetBase {
   objects: SceneObject[];
 }
 
-export type Asset = SpriteAsset | CameraAsset | TextAsset | SceneAsset | BehaviorAsset | ColliderAsset | ContainerAsset;
+export type Asset =
+  SpriteAsset | CameraAsset | TextAsset | SceneAsset | BehaviorAsset | ColliderAsset | ContainerAsset;
 
 export function isSceneAsset(asset: Asset): asset is SceneAsset {
   return asset.type === 'scene';

src/core/model/AssetTypes.ts

@@ -1,5 +1,13 @@
 /** All asset types. Scenes are assets too, but cannot be placed in scenes. */
-export const ASSET_TYPES = ['scene', 'camera', 'sprite', 'text', 'behavior', 'collider', 'container'] as const;
+export const ASSET_TYPES = [
+  'scene',
+  'camera',
+  'sprite',
+  'text',
+  'behavior',
+  'collider',
+  'container',
+] as const;
 
 export type AssetType = (typeof ASSET_TYPES)[number];
 

src/core/model/Project.ts

@@ -1,5 +1,4 @@
-import type { Asset, ContainerAsset, SceneAsset } from './Asset';
-import { isSceneAsset } from './Asset';
+import { type Asset, type ContainerAsset, isSceneAsset, type SceneAsset } from './Asset';
 import type { SceneObject } from './SceneObject';
 
 /** Written into every document. Reserved for format migrations – the loader does not branch on it yet. */
@@ -49,7 +48,10 @@ export interface SceneObjectRef {
 }
 
 /** Objects of all scenes and container templates that satisfy `predicate`, each with its holder. */
-export function objectsWhere(project: Project, predicate: (object: SceneObject) => boolean): SceneObjectRef[] {
+export function objectsWhere(
+  project: Project,
+  predicate: (object: SceneObject) => boolean,
+): SceneObjectRef[] {
   const result: SceneObjectRef[] = [];
   for (const holder of objectHolders(project)) {
     for (const object of holder.objects) if (predicate(object)) result.push({ holder, object });

src/core/model/SceneObject.ts

@@ -37,7 +37,12 @@ export interface SceneObject {
 }
 
 /** Creates a scene object; `z` defaults to 0 when the caller only has a 2D point. */
-export function createSceneObject(id: string, assetId: string, position: Vec2 | Position, parentId = ''): SceneObject {
+export function createSceneObject(
+  id: string,
+  assetId: string,
+  position: Vec2 | Position,
+  parentId = '',
+): SceneObject {
   return {
     id,
     assetId,

src/core/model/container.ts

@@ -16,7 +16,11 @@ export interface TemplateLink {
  * asset holds the template this object was instantiated from. Undefined for everything else
  * (no template id, or the link is stale).
  */
-export function templateLinkOf(project: Project, tree: ObjectTree, object: SceneObject): TemplateLink | undefined {
+export function templateLinkOf(
+  project: Project,
+  tree: ObjectTree,
+  object: SceneObject,
+): TemplateLink | undefined {
   if (!object.templateId) return undefined;
   for (const containerObject of chainOf(tree, object).slice(1)) {
     const asset = findAsset(project, containerObject.assetId);
@@ -46,12 +50,19 @@ const MAX_NESTING = 8;
  * turn – unless the template already spells its content out (that is what a container built
  * from a selection containing another container does).
  */
-export function instantiateContainer(project: Project, asset: ContainerAsset, containerObjectId: string, depth = 0): SceneObject[] {
+export function instantiateContainer(
+  project: Project,
+  asset: ContainerAsset,
+  containerObjectId: string,
+  depth = 0,
+): SceneObject[] {
   const ids = new Map(asset.objects.map((t) => [t.id, newId()]));
   const result: SceneObject[] = [];
   for (const template of asset.objects) {
     const id = ids.get(template.id)!;
-    const parentId = template.parentId ? ids.get(template.parentId) ?? containerObjectId : containerObjectId;
+    const parentId = template.parentId
+      ? (ids.get(template.parentId) ?? containerObjectId)
+      : containerObjectId;
     result.push({
       id,
       assetId: template.assetId,

src/core/model/hierarchy.ts

@@ -31,7 +31,11 @@ function parentOf(tree: ObjectTree, object: SceneObject): SceneObject | undefine
 
 /** All objects below `id`, depth-first, parents before children. */
 export function descendantsOf(tree: ObjectTree, id: string): SceneObject[] {
-  return descendantsBelow(id, (parentId) => childrenOf(tree, parentId), (o) => o.id);
+  return descendantsBelow(
+    id,
+    (parentId) => childrenOf(tree, parentId),
+    (o) => o.id,
+  );
 }
 
 /** The ids of `rootIds` and of everything below them – what group operations act on. */
@@ -58,7 +62,11 @@ export function chainOf(tree: ObjectTree, object: SceneObject): SceneObject[] {
 /** Ids of the ancestors of `id`, nearest parent first. Empty for a top-level object. */
 export function ancestorIdsOf(tree: ObjectTree, id: string): string[] {
   const object = findObject(tree, id);
-  return object ? chainOf(tree, object).slice(1).map((o) => o.id) : [];
+  return object
+    ? chainOf(tree, object)
+        .slice(1)
+        .map((o) => o.id)
+    : [];
 }
 
 /** Whether `ancestorId` is `objectId` itself or one of its ancestors. */
@@ -80,7 +88,10 @@ function positionAlongChain(tree: ObjectTree, object: SceneObject, withEditorOff
   return sumAlongChain(
     object,
     (o) => parentOf(tree, o),
-    (o) => (withEditorOffset ? { x: o.position.x + o.editorOffset.x, y: o.position.y + o.editorOffset.y, z: o.position.z } : o.position),
+    (o) =>
+      withEditorOffset
+        ? { x: o.position.x + o.editorOffset.x, y: o.position.y + o.editorOffset.y, z: o.position.z }
+        : o.position,
   );
 }
 
@@ -128,7 +139,8 @@ export function treeOrder(tree: ObjectTree): TreeEntry[] {
   visit('', 0);
   // Objects whose parent is missing (should not happen after loading) are listed at the top level.
   for (const object of tree.objects) {
-    if (object.parentId && !ids.has(object.parentId) && !result.some((e) => e.object === object)) result.push({ object, depth: 0 });
+    if (object.parentId && !ids.has(object.parentId) && !result.some((e) => e.object === object))
+      result.push({ object, depth: 0 });
   }
   return result;
 }

src/core/model/walk.ts

@@ -13,7 +13,11 @@ import type { Position } from './Properties';
  */
 export function* parentChain<T>(start: T, parentOf: (item: T) => T | null | undefined): Generator<T> {
   const seen = new Set<T>();
-  for (let current: T | null | undefined = start; current && !seen.has(current); current = parentOf(current)) {
+  for (
+    let current: T | null | undefined = start;
+    current && !seen.has(current);
+    current = parentOf(current)
+  ) {
     seen.add(current);
     yield current;
   }
@@ -31,7 +35,11 @@ export function hasParentCycle<T>(start: T, parentOf: (item: T) => T | null | un
  * The local positions of `start` and all its ancestors summed up – the world position, as
  * long as the hierarchy has no rotation or scale (it has none).
  */
-export function sumAlongChain<T>(start: T, parentOf: (item: T) => T | null | undefined, positionOf: (item: T) => Position): Position {
+export function sumAlongChain<T>(
+  start: T,
+  parentOf: (item: T) => T | null | undefined,
+  positionOf: (item: T) => Position,
+): Position {
   const total: Position = { x: 0, y: 0, z: 0 };
   for (const item of parentChain(start, parentOf)) {
     const position = positionOf(item);
@@ -47,7 +55,11 @@ export function sumAlongChain<T>(start: T, parentOf: (item: T) => T | null | und
  * back into the key its own children are looked up by, which is what lets ids (scene objects)
  * and object identity (entities) use the same walk.
  */
-export function descendantsBelow<T, K>(rootKey: K, childrenOf: (key: K) => readonly T[], keyOf: (item: T) => K): T[] {
+export function descendantsBelow<T, K>(
+  rootKey: K,
+  childrenOf: (key: K) => readonly T[],
+  keyOf: (item: T) => K,
+): T[] {
   const result: T[] = [];
   const visit = (key: K) => {
     for (const child of childrenOf(key)) {