@dcl-regenesislabs/opendcl 0.2.1-26238928766.commit-28648d7 → 0.2.1

package/skills/lighting-environment/SKILL.md

@@ -5,47 +5,22 @@ description: Dynamic lighting and environment in Decentraland scenes. LightSourc
 
 # Lighting and Environment in Decentraland
 
-## Authoring split
-
-`LightSource` is supported in `main-entities.ts` — declare the lamp's fixture model AND its light in the same entry. The user can drag the fixture in the editor and the light follows.
-
-```typescript
-// main-entities.ts
-import type { Scene } from '@dcl/sdk/scene-types'
-
-export const scene = {
-  ceiling_lamp: {
-    components: {
-      Transform: { position: { x: 8, y: 3, z: 8 } },
-      GltfContainer: { src: 'models/lamp.glb' },
-      LightSource: {
-        type: { $case: 'point', point: {} },
-        color: { r: 1, g: 1, b: 1 },
-        intensity: 16000
-      }
-    }
-  }
-} satisfies Scene
-```
-
-For purely decorative lights with no mesh, declare a Transform-only entity and skip `GltfContainer`. Toggling lights at runtime still happens in `src/index.ts` via `LightSource.getMutable(getEntityOrNullByName('ceiling_lamp'))`.
-
 ## Point Lights
 
 Emit light in all directions from a position:
 
 ```typescript
-// main-entities.ts entry
-ambient_point: {
-  components: {
-    Transform: { position: { x: 8, y: 3, z: 8 } },
-    LightSource: {
-      type: { $case: 'point', point: {} },
-      color: { r: 1, g: 1, b: 1 },
-      intensity: 16000  // candela — point lights typically need 8000–32000 to be visible
-    }
-  }
-}
+import { engine, Transform, LightSource } from '@dcl/sdk/ecs'
+import { Vector3, Color3 } from '@dcl/sdk/math'
+
+const light = engine.addEntity()
+Transform.create(light, { position: Vector3.create(8, 3, 8) })
+
+LightSource.create(light, {
+  type: LightSource.Type.Point({}),
+  color: Color3.White(),
+  intensity: 300  // candela
+})
 ```
 
 ### Colored Point Light
@@ -54,31 +29,29 @@ ambient_point: {
 LightSource.create(light, {
   type: LightSource.Type.Point({}),
   color: Color3.create(1, 0.5, 0),  // Warm orange
-  intensity: 12000,
+  intensity: 200,
   range: 15  // Maximum distance in meters
 })
 ```
 
 ## Spot Lights
 
-Emit a cone of light in a direction. The cone's orientation comes from the entity's Transform rotation.
+Emit a cone of light in a direction:
 
 ```typescript
-// main-entities.ts
-stage_spot: {
-  components: {
-    Transform: {
-      position: { x: 8, y: 4, z: 8 },
-      rotation: { x: -0.7071, y: 0, z: 0, w: 0.7071 }  // pitch -90° (down)
-    },
-    GltfContainer: { src: 'models/spotlight.glb' },
-    LightSource: {
-      type: { $case: 'spot', spot: { innerAngle: 25, outerAngle: 45 } },
-      color: { r: 1, g: 1, b: 1 },
-      intensity: 16000
-    }
-  }
-}
+import { Quaternion } from '@dcl/sdk/math'
+
+const spotlight = engine.addEntity()
+Transform.create(spotlight, {
+  position: Vector3.create(8, 4, 8),
+  rotation: Quaternion.fromEulerDegrees(-90, 0, 0)  // Point downward
+})
+
+LightSource.create(spotlight, {
+  type: LightSource.Type.Spot({ innerAngle: 25, outerAngle: 45 }),
+  color: Color3.White(),
+  intensity: 800
+})
 ```
 
 - `innerAngle` — full-brightness cone angle (degrees)
@@ -93,12 +66,10 @@ Enable shadows on point or spot lights:
 LightSource.create(spotlight, {
   type: LightSource.Type.Spot({ innerAngle: 25, outerAngle: 45 }),
   shadow: true,
-  intensity: 16000
+  intensity: 800
 })
 ```
 
-> Shadows are only available on **spot lights**, not point lights.
-
 ### Shadow Mask Textures (Gobos)
 
 Project a pattern through the light:
@@ -120,11 +91,10 @@ lightData.active = !lightData.active
 
 ## Light Limits
 
-- Maximum **one active light per parcel** (16m x 16m) — multi-parcel scenes can group lights close together when needed.
-- The renderer auto-culls lights based on quality settings and proximity. Quality range allows **4–10 lights visible simultaneously**.
-- Shadows are only available on spot lights; up to ~3 shadowed lights visible at once.
-- Intensity is in candela. Practical visible range: point lights ~8000–32000, spot lights ~10000–24000. Values below ~1000 are usually invisible.
-- Emissive materials **don't illuminate surrounding entities** — they only have a glow effect on themselves. Combine an emissive material with a `LightSource` for both.
+- Maximum **one active light per parcel** (16m x 16m)
+- The renderer auto-culls lights based on quality settings and proximity
+- Up to ~3 shadowed lights visible at once
+- Intensity is in candela — visible distance grows roughly with `sqrt(intensity)`
 
 ## SkyboxTime (Day/Night Cycle)
 
@@ -201,55 +171,38 @@ executeTask(async () => {
 
 ## Emissive Materials (Glow Effects)
 
-`Material` is supported in `main-entities.ts`, so a glow that doesn't need to cast light on surroundings can be declared inline:
+For a visual glow without casting light on surroundings:
 
 ```typescript
-// main-entities.ts
-glowing_orb: {
-  components: {
-    Transform: { position: { x: 8, y: 1, z: 8 } },
-    MeshRenderer: { mesh: { $case: 'sphere', sphere: {} } },
-    Material: {
-      material: {
-        $case: 'pbr',
-        pbr: {
-          albedoColor: { r: 0, g: 0, b: 0, a: 1 },
-          emissiveColor: { r: 0, g: 1, b: 0 },
-          emissiveIntensity: 2.0
-        }
-      }
-    }
-  }
-}
+import { engine, Material } from '@dcl/sdk/ecs'
+import { Color4, Color3 } from '@dcl/sdk/math'
+
+// Self-illuminated material (emissiveColor uses Color3, not Color4)
+Material.setPbrMaterial(entity, {
+  albedoColor: Color4.create(0, 0, 0, 1),
+  emissiveColor: Color3.create(0, 1, 0),  // Green glow
+  emissiveIntensity: 2.0
+})
 ```
 
 ### Combining Emissive + LightSource
 
-A single entity can carry both — emissive glow on the material AND light emission.
+For an object that both glows visually and casts light:
 
 ```typescript
-// main-entities.ts
-bulb: {
-  components: {
-    Transform: { position: { x: 8, y: 3, z: 8 } },
-    GltfContainer: { src: 'models/bulb.glb' },
-    Material: {
-      material: {
-        $case: 'pbr',
-        pbr: {
-          emissiveColor: { r: 1, g: 0.9, b: 0.7 },
-          emissiveIntensity: 1.5
-        }
-      }
-    },
-    LightSource: {
-      type: { $case: 'point', point: {} },
-      color: { r: 1, g: 0.9, b: 0.7 },
-      intensity: 12000,
-      range: 10
-    }
-  }
-}
+// Visual glow on the mesh
+Material.setPbrMaterial(bulb, {
+  emissiveColor: Color3.create(1, 0.9, 0.7),
+  emissiveIntensity: 1.5
+})
+
+// Actual light emission
+LightSource.create(bulb, {
+  type: LightSource.Type.Point({}),
+  color: Color3.create(1, 0.9, 0.7),
+  intensity: 200,
+  range: 10
+})
 ```
 
 ### Shadow Types
@@ -267,7 +220,7 @@ LightSource.create(spotEntity, {
     shadow: PBLightSource_ShadowType.ST_SOFT
   }),
   shadow: true,
-  intensity: 16000
+  intensity: 800
 })
 ```
 

package/skills/multiplayer-sync/SKILL.md

@@ -5,36 +5,7 @@ description: Synchronize state between players in Decentraland using CRDT networ
 
 # Multiplayer Synchronization in Decentraland
 
-## Authoring split
-
-`syncEntity()` adds a `NetworkEntity` component at runtime — and `NetworkEntity` is **not** in `main-entities.ts`'s supported component list. The pattern is:
-
-- **Predefined synced entities** (a door, a switch, a scoreboard — known at author time): declare them in `main-entities.ts` with their visual components. Look them up in `src/index.ts` and call `syncEntity(entity, [...componentIds], SyncIds.NAME)` there.
-- **Dynamically-spawned synced entities** (projectiles, drops, runtime-created game objects): create with `engine.addEntity()` in `src/index.ts` and `syncEntity` immediately.
-
-```typescript
-// main-entities.ts
-door: {
-  components: {
-    Transform: { position: { x: 8, y: 1, z: 8 } },
-    MeshRenderer: { mesh: { $case: 'box', box: { uvs: [] } } }
-  }
-}
-```
-
-```typescript
-// src/index.ts
-import { engine, Transform, syncEntity } from '@dcl/sdk/network'
-
-export function main() {
-  const door = engine.getEntityOrNullByName('door')
-  if (door) syncEntity(door, [Transform.componentId], SyncIds.DOOR)
-}
-```
-
-Decentraland scenes are inherently multiplayer — every player in the same scene shares the same space. **By default, however, players interact with the environment independently — changes one player makes are NOT shared with others.** Opt in to sharing by wrapping mutable state in `syncEntity`, broadcasting events through `MessageBus`, or persisting through your own backend.
-
-`syncEntity` state persists only as long as **at least one player remains in the scene**. The state resets as soon as the scene is empty. For durable state across scene resets, persist to your own server.
+Decentraland scenes are inherently multiplayer. All players in the same scene share the same space. SDK7 uses CRDT-based synchronization.
 
 > **Runtime constraint:** Decentraland runs in a QuickJS sandbox. No Node.js APIs (`fs`, `http`, `path`, `process`). Use `fetch()` and `WebSocket` for network communication. See the **scene-runtime** skill for async patterns.
 
@@ -53,7 +24,7 @@ Choose the right networking approach based on what you need:
 **Decision flow:**
 1. Does every player need to see the same state, including late joiners? --> `syncEntity`
 2. Is it a fire-and-forget event only for players currently in the scene? --> `MessageBus`
-3. Do you need state persisted after all players leave, or server-side validation? --> external server via `fetch` or `signedFetch`
+3. Do you need to talk to an external server? --> `fetch` or `signedFetch`
 4. Do you need continuous real-time server communication? --> `WebSocket`
 5. Combine approaches freely: use `syncEntity` for world state, `MessageBus` for effects, and `fetch` for persistence.
 

package/skills/nft-blockchain/SKILL.md

@@ -7,27 +7,24 @@ description: NFT display and blockchain interaction in Decentraland. NftShape (f
 
 ## Display NFT Artwork
 
-`NftShape` is supported in `main-entities.ts` — declare the framed NFT directly. The user can drag it around in the visual editor.
+Show an NFT from Ethereum in a decorative frame:
 
 ```typescript
-// main-entities.ts
-import type { Scene } from '@dcl/sdk/scene-types'
-
-export const scene = {
-  hero_nft: {
-    components: {
-      Transform: { position: { x: 8, y: 2, z: 8 } },
-      NftShape: {
-        urn: 'urn:decentraland:ethereum:erc721:0x06012c8cf97bead5deae237070f9587f8e7a266d:558536',
-        color: { r: 1, g: 1, b: 1, a: 1 },
-        style: 0  // NftFrameType.NFT_CLASSIC — enum values are integers in the literal
-      }
-    }
-  }
-} satisfies Scene
-```
+import { engine, Transform, NftShape, NftFrameType } from '@dcl/sdk/ecs'
+import { Vector3, Quaternion, Color4 } from '@dcl/sdk/math'
+
+const nftFrame = engine.addEntity()
+Transform.create(nftFrame, {
+  position: Vector3.create(8, 2, 8),
+  rotation: Quaternion.fromEulerDegrees(0, 0, 0)
+})
 
-The `style` field is a numeric enum — the literal cannot reference `NftFrameType.NFT_CLASSIC` directly because the AST walker only accepts JSON-compatible expressions. Use the integer value (table below) and leave a comment.
+NftShape.create(nftFrame, {
+  urn: 'urn:decentraland:ethereum:erc721:0x06012c8cf97bead5deae237070f9587f8e7a266d:558536',
+  color: Color4.White(),
+  style: NftFrameType.NFT_CLASSIC
+})
+```
 
 ### NFT URN Format
 
@@ -40,33 +37,31 @@ urn:decentraland:ethereum:erc721:<contractAddress>:<tokenId>
 
 ### Available Frame Styles
 
-| value | enum name | description |
-|---|---|---|
-| 0  | NFT_CLASSIC          | Simple classic frame |
-| 1  | NFT_BAROQUE_ORNAMENT | Ornate baroque |
-| 2  | NFT_DIAMOND_ORNAMENT | Diamond pattern |
-| 3  | NFT_MINIMAL_WIDE     | Minimal wide border |
-| 4  | NFT_MINIMAL_GREY     | Minimal grey border |
-| 5  | NFT_BLOCKY           | Pixelated/blocky |
-| 6  | NFT_GOLD_EDGES       | Gold edge trim |
-| 7  | NFT_GOLD_CARVED      | Carved gold |
-| 8  | NFT_GOLD_WIDE        | Wide gold border |
-| 9  | NFT_GOLD_ROUNDED     | Rounded gold |
-| 10 | NFT_METAL_MEDIUM     | Medium metal |
-| 11 | NFT_METAL_WIDE       | Wide metal |
-| 12 | NFT_METAL_SLIM       | Slim metal |
-| 13 | NFT_METAL_ROUNDED    | Rounded metal |
-| 14 | NFT_PINS             | Pinned to wall |
-| 15 | NFT_MINIMAL_BLACK    | Minimal black |
-| 16 | NFT_MINIMAL_WHITE    | Minimal white |
-| 17 | NFT_TAPE             | Taped to wall |
-| 18 | NFT_WOOD_SLIM        | Slim wood |
-| 19 | NFT_WOOD_WIDE        | Wide wood |
-| 20 | NFT_WOOD_TWIGS       | Twig/branch wood |
-| 21 | NFT_CANVAS           | Canvas style |
-| 22 | NFT_NONE             | No frame |
-
-In `src/index.ts` where enum identifiers are allowed, use `NftFrameType.NFT_CLASSIC` etc. directly.
+```typescript
+NftFrameType.NFT_CLASSIC            // Simple classic frame
+NftFrameType.NFT_BAROQUE_ORNAMENT   // Ornate baroque
+NftFrameType.NFT_DIAMOND_ORNAMENT   // Diamond pattern
+NftFrameType.NFT_MINIMAL_WIDE       // Minimal wide border
+NftFrameType.NFT_MINIMAL_GREY       // Minimal grey border
+NftFrameType.NFT_BLOCKY             // Pixelated/blocky
+NftFrameType.NFT_GOLD_EDGES         // Gold edge trim
+NftFrameType.NFT_GOLD_CARVED        // Carved gold
+NftFrameType.NFT_GOLD_WIDE          // Wide gold border
+NftFrameType.NFT_GOLD_ROUNDED       // Rounded gold
+NftFrameType.NFT_METAL_MEDIUM       // Medium metal
+NftFrameType.NFT_METAL_WIDE         // Wide metal
+NftFrameType.NFT_METAL_SLIM         // Slim metal
+NftFrameType.NFT_METAL_ROUNDED      // Rounded metal
+NftFrameType.NFT_PINS               // Pinned to wall
+NftFrameType.NFT_MINIMAL_BLACK      // Minimal black
+NftFrameType.NFT_MINIMAL_WHITE      // Minimal white
+NftFrameType.NFT_TAPE               // Taped to wall
+NftFrameType.NFT_WOOD_SLIM          // Slim wood
+NftFrameType.NFT_WOOD_WIDE          // Wide wood
+NftFrameType.NFT_WOOD_TWIGS         // Twig/branch wood
+NftFrameType.NFT_CANVAS             // Canvas style
+NftFrameType.NFT_NONE               // No frame
+```
 
 ## Check Player Wallet
 

package/skills/optimize-scene/SKILL.md

@@ -5,15 +5,9 @@ description: Optimize Decentraland scene performance. Scene limit formulas (tria
 
 # Optimizing Decentraland Scenes
 
-## Authoring split
-
-The patterns in this skill — object pools, LOD, asset preloading, system throttling — are all **runtime mechanics** and live in `src/index.ts`. The static layout (chairs, walls, lamps, the props that get LOD'd) should still be declared in `main-entities.ts`; the optimization code reads those entities by name (`engine.getEntityOrNullByName`) or by component query (`engine.getEntitiesWith(Transform)`).
-
-The parenting optimization (a static container with many children) is best expressed in `main-entities.ts` using `Transform.parent: 'parent_name'` — that way the editor can move the entire group as a unit.
-
 ## Scene Limits (Per Parcel Count)
 
-All limits scale with parcel count `n`. Triangles, entities, and bodies scale linearly. Materials, textures, and height scale logarithmically. **Except for hard MB size limits on deploy, all other limits CAN be exceeded** — scenes won't crash, but performance degrades and the scene may become unusable on lower-end devices. Treat the numbers as guidelines, not enforcement.
+All limits scale with parcel count `n`. Triangles, entities, and bodies scale linearly. Materials, textures, and height scale logarithmically.
 
 | Resource | Formula | 1 parcel | 2 parcels | 4 parcels | 9 parcels | 16 parcels |
 |---|---|---|---|---|---|---|
@@ -106,6 +100,7 @@ MeshRenderer.setPlane(entity)  // Very cheap
 
 - **Dimensions must be power-of-two**: 256, 512, 1024, 2048
 - **Recommended sizes**: 512x512 for most objects, 1024x1024 max for hero pieces
+- **Avoid textures over 2048x2048** — they consume excessive memory and often exceed limits
 - Use `.png` for UI/sprites with transparency
 - Use `.jpg` for photos and textures without transparency
 - Prefer compressed formats (WebP) over raw PNG where possible

package/skills/player-avatar/SKILL.md

@@ -5,30 +5,6 @@ description: Player and avatar system in Decentraland. Read player position/prof
 
 # Player and Avatar System in Decentraland
 
-## Authoring split
-
-`AvatarShape` (the component used for NPCs and pre-placed avatars) is supported in `main-entities.ts` — declare the NPC fully there with id, name, wearables, etc.:
-
-```typescript
-// main-entities.ts
-shopkeeper: {
-  components: {
-    Transform: { position: { x: 8, y: 0, z: 8 } },
-    AvatarShape: {
-      id: 'shopkeeper-1',
-      name: 'Shopkeeper',
-      bodyShape: 'urn:decentraland:off-chain:base-avatars:BaseMale',
-      wearables: [],
-      emotes: []
-    }
-  }
-}
-```
-
-`AvatarAttach`, `AvatarModifierArea`, `AvatarBase`, `AvatarEquippedData` are **not** in the supported list — they're runtime by design (they bind to the live player, or apply to entities you create on-the-fly). Add them in `src/index.ts` and attach to entities looked up via `getEntityOrNullByName` (for static placement) or runtime-created entities (for player-bound effects).
-
-The reserved `engine.PlayerEntity` is engine-managed and has no representation in `main-entities.ts`.
-
 ## Player Position and Movement
 
 Access the player's position via the reserved `engine.PlayerEntity`:
@@ -85,36 +61,6 @@ function main() {
 - `userId` — the player's Ethereum wallet address (or guest ID)
 - `isGuest` — `true` if the player hasn't connected a wallet
 
-### Fetch Full Avatar Profile from the Catalyst
-
-`getPlayer()` returns the local view of the player. For full avatar data (wearables list, body shape, skin/hair/eye colors), fetch from the Catalyst:
-
-```typescript
-import { executeTask, signedFetch } from '@dcl/sdk/network'
-import { getPlayer } from '@dcl/sdk/players'
-
-executeTask(async () => {
-  const player = getPlayer()
-  if (!player || player.isGuest) return
-
-  const res = await fetch(`https://peer.decentraland.org/lambdas/profiles/${player.userId}`)
-  const body = await res.json()
-
-  // Response is an array of profiles; the first entry holds the active avatar.
-  const profile = body?.avatars?.[0]
-  if (!profile) return
-
-  console.log('name:', profile.name)
-  console.log('wearables:', profile.avatar.wearables)
-  console.log('skin color:', profile.avatar.skin.color)  // { r, g, b } — already unwrapped, NOT { color: { r,g,b } }
-})
-```
-
-**Gotchas:**
-- The response is `{ avatars: [...] }`, not a flat profile object. Always read `body.avatars[0]`.
-- Color fields (`skin.color`, `hair.color`, `eyes.color`) are already `{ r, g, b }` objects — don't unwrap one more level.
-- The fetch is unauthenticated; for endpoints that need the player's signed identity, use `signedFetch` from `@dcl/sdk/network` instead of plain `fetch`.
-
 ## Avatar Attachments
 
 Attach 3D objects to a player's avatar:
@@ -133,36 +79,12 @@ AvatarAttach.create(hat, {
 
 ### Anchor Points
 
-Full enum of bones / positions an attachment can track. Inside `main-entities.ts` use the integer value (left). In `src/index.ts` use `AvatarAnchorPointType.<NAME>`.
-
-| value | enum | location |
-|---|---|---|
-| 0  | AAPT_POSITION       | avatar feet (deprecated — prefer `parent: engine.PlayerEntity`) |
-| 1  | AAPT_NAME_TAG       | above the name tag |
-| 2  | AAPT_LEFT_HAND      | left hand |
-| 3  | AAPT_RIGHT_HAND     | right hand |
-| 4  | AAPT_HEAD           | head bone |
-| 5  | AAPT_NECK           | neck |
-| 6  | AAPT_SPINE          | spine root |
-| 7  | AAPT_SPINE1         | spine mid |
-| 8  | AAPT_SPINE2         | spine top |
-| 9  | AAPT_HIP            | hip |
-| 10 | AAPT_LEFT_SHOULDER  | left shoulder |
-| 11 | AAPT_LEFT_ARM       | left upper arm |
-| 12 | AAPT_LEFT_FOREARM   | left forearm |
-| 13 | AAPT_LEFT_HAND_INDEX | left index finger |
-| 14 | AAPT_RIGHT_SHOULDER | right shoulder |
-| 15 | AAPT_RIGHT_ARM      | right upper arm |
-| 16 | AAPT_RIGHT_FOREARM  | right forearm |
-| 17 | AAPT_RIGHT_HAND_INDEX | right index finger |
-| 18 | AAPT_LEFT_UP_LEG    | left thigh |
-| 19 | AAPT_LEFT_LEG       | left calf |
-| 20 | AAPT_LEFT_FOOT      | left foot |
-| 21 | AAPT_LEFT_TOE_BASE  | left toes |
-| 22 | AAPT_RIGHT_UP_LEG   | right thigh |
-| 23 | AAPT_RIGHT_LEG      | right calf |
-| 24 | AAPT_RIGHT_FOOT     | right foot |
-| 25 | AAPT_RIGHT_TOE_BASE | right toes |
+```typescript
+AvatarAnchorPointType.AAPT_NAME_TAG      // Above the head
+AvatarAnchorPointType.AAPT_RIGHT_HAND    // Right hand
+AvatarAnchorPointType.AAPT_LEFT_HAND     // Left hand
+AvatarAnchorPointType.AAPT_POSITION      // Avatar root position
+```
 
 ### Attach to a Specific Player
 
@@ -308,46 +230,9 @@ AvatarLocomotionSettings.createOrReplace(engine.PlayerEntity, {
 })
 ```
 
-## InputModifier — Restrict Player Movement
-
-Disable specific movement modes for the local player. Useful for cutscenes, dialogue freezes, traversal puzzles. Applies to `engine.PlayerEntity`.
-
-```typescript
-import { engine, InputModifier } from '@dcl/sdk/ecs'
-
-InputModifier.createOrReplace(engine.PlayerEntity, {
-  mode: InputModifier.Mode.Standard({
-    disableWalk: false,
-    disableJog: false,
-    disableRun: false,
-    disableJump: false,
-    disableDoubleJump: false,
-    disableGliding: false
-  })
-})
-```
-
-Set any field to `true` to disable that mode. While disabled:
-- Gravity still applies (the player still falls).
-- The camera can still rotate freely.
-- The player can still trigger pointer / proximity events.
-- All restrictions are auto-lifted when the player leaves the scene.
-
-### Freeze All Movement
-
-```typescript
-InputModifier.createOrReplace(engine.PlayerEntity, {
-  mode: InputModifier.Mode.Standard({ disableAll: true })
-})
-```
-
-To release: `InputModifier.deleteFrom(engine.PlayerEntity)` — or `createOrReplace` with all flags `false`.
-
 ## Teleporting the Player
 
-**You MUST use `movePlayerTo` from `~system/RestrictedActions` to move or teleport the player.** Setting `Transform.getMutable(engine.PlayerEntity).position` does NOT work — the runtime ignores direct writes to the player transform. `Transform` on `engine.PlayerEntity` is **read-only**; the same applies to `engine.CameraEntity`.
-
-`movePlayerTo` only teleports the player **within the same scene**. Cross-scene teleports require explicit player consent and a different API.
+**You MUST use `movePlayerTo` from `~system/RestrictedActions` to move or teleport the player.** Setting `Transform.getMutable(engine.PlayerEntity).position` does NOT work — the runtime ignores direct writes to the player transform.
 
 ```typescript
 import { movePlayerTo } from '~system/RestrictedActions'
@@ -364,17 +249,6 @@ void movePlayerTo({
 })
 ```
 
-`movePlayerTo` returns a Promise — `await` it if you need to chain actions:
-
-```typescript
-import { executeTask } from '@dcl/sdk/ecs'
-
-executeTask(async () => {
-  await movePlayerTo({ newRelativePosition: Vector3.create(8, 0, 8) })
-  console.log('teleported, continuing flow')
-})
-```
-
 ### Avatar Change Listeners
 
 React to avatar changes in real-time:

package/skills/scene-runtime/SKILL.md

@@ -153,16 +153,12 @@ changeRealm({ realm: 'other-realm.dcl.eth', message: 'Join this realm?' })
 
 ## Timers
 
-**Use the `timers` API from `@dcl/sdk/ecs`**, not the global `setTimeout`/`setInterval`. The globals are not reliable in the QuickJS runtime.
+**setTimeout / setInterval** are supported via the QuickJS runtime polyfill:
 
 ```typescript
-import { timers } from '@dcl/sdk/ecs'
-
-const t = timers.setTimeout(() => console.log('delayed'), 2000)
-timers.clearTimeout(t)
-
-const id = timers.setInterval(() => console.log('tick'), 1000)
-timers.clearInterval(id)
+setTimeout(() => console.log('delayed'), 2000)
+const id = setInterval(() => console.log('tick'), 1000)
+clearInterval(id)
 ```
 
 **System-based timers** (recommended for game logic — synchronized with the frame loop):
@@ -255,7 +251,7 @@ npx @dcl/sdk-commands test
 
 - Always wrap async code in `executeTask()` — bare promises will be silently dropped
 - Use `signedFetch` (not plain `fetch`) when your backend needs to verify the player's identity
-- Prefer system-based timers over `timers.setTimeout`/`timers.setInterval` for game logic — they stay in sync with the frame loop. Use `timers.*` for one-shot scheduled actions (auto-close door, delayed sound, etc.).
+- Prefer system-based timers over `setTimeout`/`setInterval` for game logic — they stay in sync with the frame loop
 - Check `realm.realmInfo?.isPreview` to detect preview mode and enable debug features
 - Use `readFile()` for data files (JSON configs, level data) deployed alongside the scene
 - `removeEntityWithChildren()` is essential when cleaning up complex entity hierarchies

package/skills/visual-feedback/SKILL.md

@@ -106,7 +106,6 @@ Keep it to 1-2 screenshots per task. Each screenshot consumes significant tokens
 | Missing textures (pink/magenta) | Texture file not found or wrong path | Verify file exists in project and path matches code |
 | Objects appear wrong scale | Scale values off or model exported at wrong scale | Check Transform.scale values; 1,1,1 is original model size |
 | Lighting looks flat | No LightSource components in scene | Add point or spot lights — see **lighting-environment** skill |
-| Custom lights look too dim or invisible | Intensity value too low | Point/spot lights typically need `intensity: 8000–32000` candela. Values below ~1000 are usually invisible |
 
 ## What to Look For in Screenshots