@dcl-regenesislabs/opendcl 0.2.1-26502482653.commit-5089b10 → 0.2.1

package/prompts/system.md

@@ -25,58 +25,26 @@ You are **OpenDCL**, an AI coding assistant specialized in Decentraland SDK7 sce
 - 1 parcel: ~512 entities, ~10,000 triangles. Scales with parcel count.
 - All coordinates are in meters. Y is up. Scene origin (0,0,0) is the southwest corner of the base parcel at ground level.
 
-### Authoring Model: Data in `main-entities.ts`, Behavior in `src/`
+### Key Patterns
 
-OpenDCL scenes split the source of truth in two:
-
-- **`main-entities.ts`** at the scene root — typed declarative entities keyed by Name, with their data components (Transform, GltfContainer, MeshRenderer, Material, AudioSource, etc.). Compiled to `main.crdt` at build time and preloaded by the engine before `main()` runs.
-- **`src/index.ts`** — behavior only. References entities by Name and attaches systems, pointer events, tweens.
-
-**Adding a declared entity (in `main-entities.ts`):**
-```typescript
-import type { Scene } from '@dcl/sdk/scene-types'
-
-export const scene = {
-  blue_cube: {
-    components: {
-      Transform: { position: { x: 8, y: 1, z: 8 }, rotation: { x: 0, y: 0, z: 0, w: 1 }, scale: { x: 1, y: 1, z: 1 } },
-      MeshRenderer: { mesh: { $case: 'box', box: { uvs: [] } } },
-      Material: { material: { $case: 'pbr', pbr: { albedoColor: { r: 1, g: 0, b: 0, a: 1 } } } },
-    },
-  },
-} satisfies Scene
-```
-
-**Referencing it in code:**
+**Creating an entity with components:**
 ```typescript
-import { engine, pointerEventsSystem, InputAction } from '@dcl/sdk/ecs'
-import type { scene } from '../main-entities'
+import { engine, Transform, MeshRenderer, Material } from '@dcl/sdk/ecs'
+import { Vector3, Color4 } from '@dcl/sdk/math'
 
-type EntityName = keyof typeof scene
-
-export function main() {
-  const cube = engine.getEntityOrNullByName<EntityName>('blue_cube')
-  if (cube === null) return
-
-  pointerEventsSystem.onPointerDown(
-    { entity: cube, opts: { button: InputAction.IA_POINTER, hoverText: 'Click me' } },
-    () => { /* handle click */ },
-  )
-}
+const cube = engine.addEntity()
+Transform.create(cube, { position: Vector3.create(8, 1, 8) })
+MeshRenderer.setBox(cube)
+Material.setPbrMaterial(cube, { albedoColor: Color4.Red() })
 ```
 
-**Rules:**
-- Every declarative entity goes in `main-entities.ts` with a unique Name. The `satisfies Scene` clause keeps literal keys typed for safe references.
-- Parents are referenced by Name (`parent: 'barrel_1'`); the build resolves them.
-- Pure-data components (Transform, GltfContainer, MeshRenderer, MeshCollider, Material, AudioSource, VideoPlayer, TextShape, Animator config, NftShape, Billboard, VisibilityComponent) all live in `main-entities.ts`.
-- Behavior, callbacks, systems, conditional logic stay in `src/`.
-- The `scene` literal must contain only JSON-compatible values — no function calls, no spreads, no comments inside the object.
-
-**Dynamic entities** spawned at runtime (effects, projectiles, runtime markers) still use `engine.addEntity()` and **don't get Names** — they're invisible to the editor and not persisted:
+**Adding interactivity:**
 ```typescript
-const explosion = engine.addEntity()
-Transform.create(explosion, { position: Vector3.create(...) })
-GltfContainer.create(explosion, { src: 'models/Explosion.glb' })
+import { pointerEventsSystem, InputAction } from '@dcl/sdk/ecs'
+
+pointerEventsSystem.onPointerDown({ entity: cube, opts: { button: InputAction.IA_POINTER, hoverText: 'Click me' } }, () => {
+  // Handle click
+})
 ```
 
 **Systems (per-frame logic):**
@@ -105,11 +73,10 @@ export function setupUi() {
 ```
 scene-project/
 ├── scene.json          # Scene metadata (parcels, title, main entry)
-├── main-entities.ts    # Declarative entities (data) — preloaded into the engine before main() runs
 ├── package.json        # Dependencies (@dcl/sdk)
-├── tsconfig.json       # TypeScript config (must include main-entities.ts)
+├── tsconfig.json       # TypeScript config
 └── src/
-    ├── index.ts        # Main entry point — references entities by Name, attaches behavior
+    ├── index.ts        # Main entry point (export function main)
     └── ui.tsx          # UI components (optional)
 ```
 
@@ -127,25 +94,19 @@ scene-project/
 ## How to Help Users
 
 ### Empty Folder (No scene.json)
-**Do NOT ask the user what they want to build.** Instead, immediately run the `init` tool to scaffold the project — no questions, no menu of options, just init. This uses the official SDK scaffolding to create scene.json, package.json, tsconfig.json, and src/index.ts with the correct, up-to-date configuration, and installs dependencies. Never create these files manually. After init completes, ask the user what they'd like to do next. Offer small, concrete steps — don't propose building an entire scene at once.
+1. Ask the user what they want to build.
+2. **Use the `init` tool first** — this uses the official SDK scaffolding to create scene.json, package.json, tsconfig.json, and src/index.ts with the correct, up-to-date configuration, and installs dependencies. Never create these files manually.
+3. After init completes, customize `scene.json` (title, description, parcels) and add the first element to `src/index.ts`. Then offer next steps — don't build the entire scene at once.
 
 ### Existing Scene
-1. Read scene.json, main-entities.ts (if it exists), and src/index.ts to understand the project.
+1. Read scene.json and src/index.ts to understand the project.
 2. Offer contextual help — adding features, fixing bugs, optimizing.
 3. Always preserve existing code when making edits.
-4. When adding a new declarative entity (cube, model, lamp, etc.), edit `main-entities.ts` and reference the new Name from `src/index.ts` if it needs behavior. Don't reach for `engine.addEntity()` in code as a default.
 
 ### Best Practices
-
-**Always declare static / editable entities in `main-entities.ts`** — never via `engine.addEntity()` in `src/index.ts` for things the user might want to move, rotate, or see in the visual editor. Entities declared in `main-entities.ts` are preloaded by the engine before `main()` runs, are visible in the editor's hierarchy panel, and are draggable. Entities created at runtime via `engine.addEntity()` are invisible to the editor and lost when the user reloads.
-
-Use `engine.addEntity()` only for genuinely dynamic things (effects spawned at runtime, projectiles, throwaway markers). Those entities should NOT have a `Name` component — Naming is the marker for "this entity belongs in main-entities.ts."
-
-When the user asks to add a barrel, a tree, a prop, a model — that goes in `main-entities.ts` first, and code references it via `engine.getEntityOrNullByName<EntityName>(name)`. Don't fall back to the old `addEntity + Transform.create + GltfContainer.create` pattern in code unless the user explicitly asks for runtime spawning.
-
 - Always position objects within the scene boundaries (based on parcels).
-- For positions/rotations inside `main-entities.ts`, use plain object literals (`{ x: 8, y: 1, z: 8 }`), not `Vector3.create()` — the `scene` literal must stay JSON-compatible. In `src/index.ts` (behavior code), `Vector3.create()` and `Quaternion.fromEulerDegrees()` are fine.
-- For 3D models, declare `GltfContainer: { src: 'models/myModel.glb' }` inside the entity's `components` block in `main-entities.ts`.
+- Use `Vector3.create()` and `Quaternion.fromEulerDegrees()` for transforms.
+- For 3D models, use `GltfContainer.create(entity, { src: 'models/myModel.glb' })`.
 - `GltfContainer` only works with **local files** — never use external URLs for the `src` field. Always download models into the scene's `models/` directory first.
 - Place `.glb` files in a `models/` directory, textures in `images/`.
 - Don't start the preview server automatically after writing code. The user will type `/preview` when ready.
@@ -154,30 +115,39 @@ When the user asks to add a barrel, a tree, a prop, a model — that goes in `ma
   - Search with `grep -i "keyword" skills/add-3d-models/references/model-catalog.md`, fetch the preview thumbnail to confirm, then download with curl.
   - Download matching models with `curl -o models/filename.glb "URL"` before referencing them in code.
 
-### Visual Feedback
+### Visual Iteration Workflow
+
+When the preview server is running, **proactively use the `screenshot` tool after making scene changes**. Don't wait for the user to check — verify your own work:
+
+1. Write code or modify the scene.
+2. Use `screenshot` (with a `wait` of ~2000ms for hot-reload) to see the result.
+3. Describe what you see honestly — what's working, what's missing, what looks wrong.
+4. If something is off, fix it and screenshot again.
 
-When the preview server is running, use the `screenshot` tool **after completing code changes** to verify the result. Do NOT use screenshots to explore or navigate the scene.
+This way the user gets a working scene without having to open a browser and report issues back to you.
 
-1. Make all code changes first.
-2. Take **one** screenshot (with `wait: 2000` for hot-reload) to verify.
-3. Describe what you see honestly — what works, what's wrong.
-4. If something is off, fix the code and take **one more** screenshot to confirm.
+The screenshot tool supports actions before capture — move around (moveForward, moveLeft, etc.), look around (lookLeft, lookUp), click objects, press keys. Use these to explore from different angles or test interactivity.
 
-Keep it to **1-2 screenshots per task**. Each screenshot consumes significant tokens. Do not wander around taking multiple screenshots to "explore" — that wastes the user's budget.
+The browser stays open between calls — only the first screenshot takes ~15s (launch + enter scene). Subsequent ones are instant.
 
-The screenshot tool supports actions before capture (move, look, click, key press), but use these sparingly and only when needed to verify a specific thing (e.g., moving to see an object you just placed behind the spawn point).
+If the user asks you to iterate autonomously (e.g., "keep going until it looks right"):
+1. Make code changes.
+2. Wait for hot reload (~2s), then take a screenshot.
+3. Analyze whether the result matches the goal.
+4. If not, make targeted fixes and screenshot again.
+5. Repeat (up to 5 iterations) until done.
 
 ## Tools & Commands
 
 You have these Decentraland-specific tools — **use them directly** when the user's request matches:
 - `init` — Scaffold a new scene (**always use this first** in an empty folder)
 - `preview` — Start the Bevy-web preview server
-- `screenshot` — Capture a screenshot of the running preview to verify code changes. Limit to 1-2 per task.
+- `screenshot` — Capture a screenshot of the running preview. Supports movement and interaction actions before capture.
 - `deploy` — Deploy to Genesis City or a World (auto-detects from scene.json)
 - `tasks` — List or stop running background processes
 
 The user can also type these as `/init`, `/preview`, `/deploy`, `/tasks` slash commands directly.
-Additional user-only commands: `/review`, `/explain`, `/setup`
+Additional user-only commands: `/review`, `/explain`, `/setup`, `/setup-ollama`
 
 ## Pacing
 

package/skills/add-3d-models/SKILL.md

@@ -5,30 +5,27 @@ description: Add 3D models (.glb/.gltf) to a Decentraland scene using GltfContai
 
 # Adding 3D Models to Decentraland Scenes
 
-## Where models go: `main-entities.ts`
+## Loading a 3D Model
 
-A 3D model placed at author time is a static visible entity. **Declare it in `main-entities.ts`**, not via `engine.addEntity()` in `src/index.ts`. The build compiles `main-entities.ts` into `main.crdt`, the engine preloads it before `main()` runs, and the editor can drag/rotate the model interactively.
+Use `GltfContainer` to load `.glb` or `.gltf` files:
 
 ```typescript
-// main-entities.ts
-import type { Scene } from '@dcl/sdk/scene-types'
-
-export const scene = {
-  my_model: {
-    components: {
-      Transform: { position: { x: 8, y: 0, z: 8 } },
-      GltfContainer: {
-        src: 'models/myModel.glb',
-        visibleMeshesCollisionMask: 3 // CL_PHYSICS | CL_POINTER
-      }
-    }
-  }
-} satisfies Scene
-```
+import { engine, Transform, GltfContainer, ColliderLayer } from '@dcl/sdk/ecs'
+import { Vector3, Quaternion } from '@dcl/sdk/math'
 
-> **Always set `visibleMeshesCollisionMask`** on `GltfContainer`. Catalog models don't include separate collider meshes — using the visible mesh as the collider ensures the model is solid and clickable. Use the integer value (`ColliderLayer.CL_PHYSICS = 1`, `CL_POINTER = 2`, both = `3`) inside `main-entities.ts` since enums aren't allowed in the literal.
+const model = engine.addEntity()
+Transform.create(model, {
+  position: Vector3.create(8, 0, 8),
+  rotation: Quaternion.fromEulerDegrees(0, 0, 0),
+  scale: Vector3.create(1, 1, 1)
+})
+GltfContainer.create(model, {
+  src: 'models/myModel.glb',
+  visibleMeshesCollisionMask: ColliderLayer.CL_PHYSICS | ColliderLayer.CL_POINTER
+})
+```
 
-**When to use `engine.addEntity()` in `src/index.ts` instead**: only when the model is spawned dynamically (procedurally placed in a loop, dropped on an event, gated by NFT ownership, etc.). For static props, always use `main-entities.ts`.
+> **Always set `visibleMeshesCollisionMask`** when loading models. Catalog models don't include separate collider meshes — using the visible mesh as the collider ensures the model is solid and clickable.
 
 ## File Organization
 
@@ -49,80 +46,52 @@ project/
 ## Colliders
 
 ### Using Model's Built-in Colliders
-
+Models exported with collision meshes work automatically. Set the collision mask:
 ```typescript
-// main-entities.ts — declared inline with GltfContainer
-building: {
-  components: {
-    Transform: { position: { x: 8, y: 0, z: 8 } },
-    GltfContainer: {
-      src: 'models/building.glb',
-      visibleMeshesCollisionMask: 3,    // CL_PHYSICS | CL_POINTER
-      invisibleMeshesCollisionMask: 1   // CL_PHYSICS
-    }
-  }
-}
+GltfContainer.create(model, {
+  src: 'models/building.glb',
+  visibleMeshesCollisionMask: ColliderLayer.CL_PHYSICS | ColliderLayer.CL_POINTER,
+  invisibleMeshesCollisionMask: ColliderLayer.CL_PHYSICS
+})
 ```
 
 ### Adding Simple Colliders
-
-For basic shapes (no GLTF), add `MeshCollider`:
-
+For basic shapes, add `MeshCollider`:
 ```typescript
-// main-entities.ts
-invisible_wall: {
-  components: {
-    Transform: { position: { x: 0, y: 1, z: 8 }, scale: { x: 0.1, y: 2, z: 16 } },
-    MeshCollider: { mesh: { $case: 'box', box: { uvs: [] } } }
-  }
-}
+import { MeshCollider } from '@dcl/sdk/ecs'
+MeshCollider.setBox(model) // Box collider
+MeshCollider.setSphere(model) // Sphere collider
 ```
 
-Other shapes: `{ $case: 'sphere', sphere: {} }`, `{ $case: 'plane', plane: { uvs: [] } }`, `{ $case: 'cylinder', cylinder: {} }`.
-
-## ⚠️ Important: Never Pass `undefined` in Transform Fields
-
-The SDK serializer crashes if any Transform field (`position`, `rotation`, `scale`) is present but `undefined`. **Omit the key entirely** instead — both in `main-entities.ts` literals and in any runtime helpers. In `main-entities.ts` this is natural (you just don't write the field).
-
 ## Common Model Operations
 
 ### Scaling
-
 ```typescript
-// main-entities.ts
-big_statue: {
-  components: {
-    Transform: { position: { x: 8, y: 0, z: 8 }, scale: { x: 2, y: 2, z: 2 } },
-    GltfContainer: { src: 'models/statue.glb' }
-  }
-}
+Transform.create(model, {
+  position: Vector3.create(8, 0, 8),
+  scale: Vector3.create(2, 2, 2) // 2x size
+})
 ```
 
-### Rotation (Euler angles converted to a quaternion at author time)
-
-Quaternions are `{ x, y, z, w }`. For `Quaternion.fromEulerDegrees(0, 90, 0)` the equivalent literal is `{ x: 0, y: 0.7071, z: 0, w: 0.7071 }`. If you need exact-degree rotations and don't want to compute by hand, set `rotation` to identity in `main-entities.ts` and rotate at runtime in `src/index.ts` using `Transform.getMutable(entity).rotation = Quaternion.fromEulerDegrees(0, 90, 0)`.
-
-### Parenting
-
-Reference the parent by **name** (a string key from the same `scene` object). The build resolves names to entity IDs in a second pass.
+### Rotation
+```typescript
+Transform.create(model, {
+  position: Vector3.create(8, 0, 8),
+  rotation: Quaternion.fromEulerDegrees(0, 90, 0) // Rotate 90° on Y axis
+})
+```
 
+### Parenting (Attach to Another Entity)
 ```typescript
-// main-entities.ts
-character: {
-  components: {
-    Transform: { position: { x: 8, y: 0, z: 8 } },
-    GltfContainer: { src: 'models/character.glb' }
-  }
-},
-hat: {
-  components: {
-    Transform: {
-      position: { x: 0, y: 2, z: 0 },  // 2m above parent's origin
-      parent: 'character'
-    },
-    GltfContainer: { src: 'models/hat.glb' }
-  }
-}
+const parent = engine.addEntity()
+Transform.create(parent, { position: Vector3.create(8, 0, 8) })
+
+const child = engine.addEntity()
+Transform.create(child, {
+  position: Vector3.create(0, 2, 0), // 2m above parent
+  parent: parent
+})
+GltfContainer.create(child, { src: 'models/hat.glb' })
 ```
 
 ## Free 3D Models — OpenDCL Catalog (5,700+ models)
@@ -177,34 +146,19 @@ curl -o models/zombie-purple.glb "https://models.dclregenesislabs.xyz/blobs/bafy
 ```
 
 ```typescript
-// main-entities.ts — declare the entity with all its initial state
-import type { Scene } from '@dcl/sdk/scene-types'
-
-export const scene = {
-  zombie: {
-    components: {
-      Transform: { position: { x: 8, y: 0, z: 8 } },
-      GltfContainer: { src: 'models/zombie-purple.glb' },
-      Animator: {
-        states: [
-          { clip: 'ZombieWalk', playing: true, loop: true },
-          { clip: 'ZombieAttack', playing: false, loop: false }
-        ]
-      }
-    }
-  }
-} satisfies Scene
-```
-
-To switch animations at runtime (e.g., trigger attack on click), use `src/index.ts`:
+// Use in code with animations
+import { engine, Transform, GltfContainer, Animator } from '@dcl/sdk/ecs'
+import { Vector3 } from '@dcl/sdk/math'
 
-```typescript
-import { engine, Animator } from '@dcl/sdk/ecs'
-
-export function main() {
-  const zombie = engine.getEntityOrNullByName('zombie')
-  if (zombie) Animator.playSingleAnimation(zombie, 'ZombieAttack')
-}
+const zombie = engine.addEntity()
+Transform.create(zombie, { position: Vector3.create(8, 0, 8) })
+GltfContainer.create(zombie, { src: 'models/zombie-purple.glb' })
+Animator.create(zombie, {
+  states: [
+    { clip: 'ZombieWalk', playing: true, loop: true },
+    { clip: 'ZombieAttack', playing: false, loop: false }
+  ]
+})
 ```
 
 > **Important**: `GltfContainer` only works with **local files**. Never use external URLs for the model `src` field. Always download models into `models/` first.
@@ -212,23 +166,19 @@ export function main() {
 
 ### Checking Model Load State
 
-Load-state polling is runtime behavior — put it in `src/index.ts` and reference the entity by name:
+Use `GltfContainerLoadingState` to check if a model has finished loading:
 
 ```typescript
-import { engine, GltfContainerLoadingState, LoadingState } from '@dcl/sdk/ecs'
-
-export function main() {
-  engine.addSystem(() => {
-    const model = engine.getEntityOrNullByName('zombie')
-    if (!model) return
-    const state = GltfContainerLoadingState.getOrNull(model)
-    if (state?.currentState === LoadingState.FINISHED) {
-      console.log('Model loaded successfully')
-    } else if (state?.currentState === LoadingState.FINISHED_WITH_ERROR) {
-      console.log('Model failed to load')
-    }
-  })
-}
+import { GltfContainer, GltfContainerLoadingState, LoadingState } from '@dcl/sdk/ecs'
+
+engine.addSystem(() => {
+  const state = GltfContainerLoadingState.getOrNull(modelEntity)
+  if (state && state.currentState === LoadingState.FINISHED) {
+    console.log('Model loaded successfully')
+  } else if (state && state.currentState === LoadingState.FINISHED_WITH_ERROR) {
+    console.log('Model failed to load')
+  }
+})
 ```
 
 ## Troubleshooting

package/skills/add-interactivity/SKILL.md

@@ -5,37 +5,6 @@ description: Add click handlers, hover effects, pointer events, trigger areas, r
 
 # Adding Interactivity to Decentraland Scenes
 
-## Authoring split
-
-The clickable entity (cube, button, model) is static — declare it in `main-entities.ts` with its Transform / Mesh / Material. The clickability itself is **always** added at runtime in `src/index.ts` via `pointerEventsSystem.onPointerDown(...)` (or the related helpers). The helper writes the `PointerEvents` component AND registers the callback in a single call — do NOT also declare `PointerEvents` in `main-entities.ts`; the helper would just overwrite it and the duplication invites drift.
-
-```typescript
-// main-entities.ts — entity only, no PointerEvents
-clickable_cube: {
-  components: {
-    Transform: { position: { x: 8, y: 1, z: 8 } },
-    MeshRenderer: { mesh: { $case: 'box', box: { uvs: [] } } }
-  }
-}
-```
-
-```typescript
-// src/index.ts — register clickability via the helper system
-import { engine, pointerEventsSystem, InputAction } from '@dcl/sdk/ecs'
-
-export function main() {
-  const cube = engine.getEntityOrNullByName('clickable_cube')
-  if (cube) {
-    pointerEventsSystem.onPointerDown(
-      { entity: cube, opts: { button: InputAction.IA_POINTER, hoverText: 'Open' } },
-      () => { /* what happens on click */ }
-    )
-  }
-}
-```
-
-`TriggerArea` and `Raycast` are also runtime — they live in `src/index.ts`. Code examples below that create entities inline with `engine.addEntity()` are for runtime/technical entities (raycast probes, trigger volumes generated from data); for static clickable props, declare the prop in `main-entities.ts` and attach handlers in `src/index.ts` as above.
-
 ## Decision Tree
 
 | Need | Approach | API |
@@ -120,10 +89,10 @@ pointerEventsSystem.removeOnPointerUp(cube)
 ```
 
 ### Important: Colliders Required
-Pointer events only work on entities with a **collider on the `CL_POINTER` layer**. Add one if your entity doesn't have a mesh:
+Pointer events only work on entities with a **collider**. Add one if your entity doesn't have a mesh:
 ```typescript
 import { MeshCollider } from '@dcl/sdk/ecs'
-MeshCollider.setBox(entity) // Invisible box collider — defaults include CL_POINTER
+MeshCollider.setBox(entity) // Invisible box collider
 ```
 
 For GLTF models, set the collision mask:
@@ -136,47 +105,6 @@ GltfContainer.create(entity, {
 
 ---
 
-## Proximity Events (Pointer-Free Triggers)
-
-Like `pointerEventsSystem.onPointerDown`, but fires based on **player distance** to the entity instead of a click. Useful for "press E when near" interactions and signposts that highlight on approach. No collider required — the system polls the player position vs the entity transform.
-
-```typescript
-import { engine, pointerEventsSystem, InputAction } from '@dcl/sdk/ecs'
-
-const door = engine.getEntityOrNullByName('shop_door')
-if (door) {
-  pointerEventsSystem.onProximityDown(
-    {
-      entity: door,
-      opts: {
-        button: InputAction.IA_PRIMARY,
-        hoverText: 'Open shop',
-        maxPlayerDistance: 3   // metres
-      }
-    },
-    () => { /* run when the player presses the button within range */ }
-  )
-
-  pointerEventsSystem.onProximityEnter(
-    { entity: door, opts: { maxPlayerDistance: 5 } },
-    () => { /* fired once when the player enters the radius */ }
-  )
-
-  pointerEventsSystem.onProximityLeave(
-    { entity: door, opts: { maxPlayerDistance: 5 } },
-    () => { /* fired once when the player leaves the radius */ }
-  )
-}
-```
-
-- `maxPlayerDistance` is required and is measured from the **avatar root**, not the camera.
-- `priority` (number) — if multiple proximity events overlap, the higher value wins.
-- Remove with `pointerEventsSystem.removeOnProximityDown(entity)` etc.
-
-Prefer **proximity events** over `pointerEventsSystem.onPointerDown` when the entity has no visible collider or when the player shouldn't need to aim at it (signs, doors that just open when approached, etc.).
-
----
-
 ## Trigger Areas (Proximity Detection)
 
 Detect when the player enters, exits, or stays inside an area:

package/skills/advanced-input/SKILL.md

@@ -83,8 +83,6 @@ engine.addSystem(myInputSystem)
 
 ### Global Input Checks
 
-Fires regardless of whether the player's cursor was over an entity.
-
 ```typescript
 function globalInputSystem() {
   // Was the key just pressed this frame?
@@ -101,31 +99,6 @@ function globalInputSystem() {
 engine.addSystem(globalInputSystem)
 ```
 
-### Tag-Based Input Batching
-
-If you have many similar entities that all respond to the same input (e.g., every barrel responds to E to break), tag them via the `Tag` component and iterate the tag query each frame:
-
-```typescript
-import { engine, Tag, inputSystem, InputAction, PointerEventType } from '@dcl/sdk/ecs'
-
-// At setup: tag the entities (or declare Tag in main-entities.ts).
-for (const barrel of [b1, b2, b3]) {
-  Tag.createOrReplace(barrel, { value: 'breakable' })
-}
-
-engine.addSystem(() => {
-  for (const [entity] of engine.getEntitiesByTag('breakable')) {
-    const cmd = inputSystem.getInputCommand(InputAction.IA_PRIMARY, PointerEventType.PET_DOWN, entity)
-    if (cmd) {
-      // entity was the IA_PRIMARY target this frame
-      engine.removeEntity(entity)
-    }
-  }
-})
-```
-
-Cleaner than registering N individual `pointerEventsSystem.onPointerDown` handlers when the behavior is uniform.
-
 ## All InputAction Values
 
 | InputAction | Key/Button |
@@ -165,15 +138,11 @@ InputModifier.create(engine.PlayerEntity, {
   mode: InputModifier.Mode.Standard({ disableAll: true })
 })
 
-// Restrict specific movement (every flag is optional and defaults to false)
+// Restrict specific movement
 InputModifier.createOrReplace(engine.PlayerEntity, {
   mode: InputModifier.Mode.Standard({
-    disableWalk: false,
-    disableJog: false,
     disableRun: true,
     disableJump: true,
-    disableDoubleJump: true,
-    disableGliding: true,
     disableEmote: true
   })
 })
@@ -182,8 +151,6 @@ InputModifier.createOrReplace(engine.PlayerEntity, {
 InputModifier.deleteFrom(engine.PlayerEntity)
 ```
 
-While restricted: gravity still applies, the camera still rotates, and pointer / proximity events still fire. All restrictions auto-lift when the player leaves the scene.
-
 **Important:** InputModifier only works in the DCL 2.0 desktop client. It has no effect in the web browser explorer.
 
 ### Cutscene Pattern