fixes for empty gltf scene to process correctly

Author: kuruk-mm

CLAUDE.md

@@ -8,142 +8,69 @@ This is a consumer-processor service for Decentraland that processes deployments
 
 ## Essential Commands
 
-### Development
 ```bash
-# Install dependencies
-npm install
-
-# Build TypeScript
-npm run build
-
-# Run linter
-npm run lint:check
-npm run lint:fix
-
-# Run tests
-npm test
-
-# Run a specific test
-npm test -- test/unit/ping-controller.spec.ts
+npm install                # Install dependencies
+npm run build              # Build TypeScript
+npm run lint:check         # Run linter
+npm run lint:fix           # Fix lint issues
+npm test                   # Run all tests
+npm test -- test/unit/ping-controller.spec.ts  # Run specific test
+npm start                  # Start service (requires built dist/)
+PROCESS_METHOD=godot_optimizer npm start       # Start with specific runner
 ```
 
-### Running Services
+### Docker Operations (run.sh)
 
-Using the run.sh script:
 ```bash
-# Build and run a specific runner
-./run.sh --build godot-optimizer
-./run.sh --build godot-runner
-./run.sh --build crdt-runner
-
-# Build for multiple architectures (ARM64 + AMD64)
-./run.sh --build --multiarch godot-optimizer
-
-# Run without building
-./run.sh godot-optimizer
-
-# Pass additional options
-./run.sh godot-optimizer --option key value
-```
-
-Direct execution:
-```bash
-# Start the service (requires built dist/)
-npm start
-
-# With specific process method
-PROCESS_METHOD=godot_optimizer npm start
+./run.sh --build godot-optimizer               # Build and run
+./run.sh --build --multiarch godot-optimizer   # Build for ARM64 + AMD64
+./run.sh godot-optimizer                       # Run without building
 ```
 
 ### Environment Configuration
 
-Create a `.env` file based on `.env.default`. Key environment variables:
-- `PROCESS_METHOD`: One of `log`, `godot_minimap`, `godot_optimizer`, `generate_crdt`, `generate_imposters`
-- `AWS_REGION`: AWS region for SQS/S3
-- `TASK_QUEUE`: SQS queue URL
-- `BUCKET`: S3 bucket name for storage
-- `GODOT4_EDITOR`: Path to Godot editor (defaults to /usr/local/bin/godot in containers)
+Create `.env` from `.env.default`. Key variables:
+- `PROCESS_METHOD`: `log`, `godot_minimap`, `godot_optimizer`, `generate_crdt`, `generate_imposters`
+- `TASK_QUEUE`: SQS URL (if unset, uses in-memory queue)
+- `BUCKET`: S3 bucket (if unset, uses local `./storage`)
+- `GODOT4_EDITOR`: Path to Godot (default: `/usr/local/bin/godot` in containers)
 
 ## Architecture
 
-### Core Components
+### Dependency Injection Pattern
 
-1. **Service Layer** (`src/service.ts`): Main entry point that wires components and starts the processing loop based on `PROCESS_METHOD`
+Uses `@well-known-components` framework. Components defined in `src/components.ts` with interfaces in `src/types.ts`. All adapters implement standard interfaces allowing swap between AWS services and local mocks via environment variables.
 
-2. **Runners** (`src/runners/`): Different processing pipelines
-   - `godot-optimizer/`: Asset optimization using Godot engine
-   - `minimap-generator/`: Scene minimap generation
-   - `crdt-runner/`: CRDT file generation from deployments
-   - `imposter-runner/`: Imposter mesh generation
+### Core Structure
 
-3. **Adapters** (`src/adapters/`): External service integrations
-   - `sqs.ts`: AWS SQS queue consumer/publisher
-   - `storage.ts`: S3 or local file storage
-   - `sns.ts`: AWS SNS notifications
-   - `runner.ts`: Task runner management
-
-4. **Components** (`src/components.ts`): Dependency injection setup using well-known-components pattern
+- **`src/service.ts`**: Main processing loop, routes messages to runners based on `PROCESS_METHOD`
+- **`src/adapters/`**: External integrations (SQS, S3, SNS) with dual implementations (AWS + local/memory)
+- **`src/runners/`**: Processing pipelines (godot-optimizer, minimap-generator, crdt-runner, imposter-runner)
 
 ### Processing Flow
 
-1. Service polls SQS queue for deployment messages
-2. Based on `PROCESS_METHOD`, routes to appropriate runner
-3. Runner downloads assets from content server
-4. Processes assets (optimize, generate minimap, etc.)
-5. Uploads results to S3/storage
-6. Publishes completion notification to SNS
+1. Service polls SQS (or memory queue) for `DeploymentToSqs` messages
+2. Routes to runner based on `PROCESS_METHOD`
+3. Runner downloads assets from content server, processes them
+4. Uploads results to S3/storage
+5. Publishes completion to SNS, reports to monitoring service
 
 ### Docker Architecture
 
-The project supports multi-architecture builds (AMD64 and ARM64):
-- AMD64: Uses Decentraland's fork of Godot 4.4.1
-- ARM64: Uses official Godot 4.4.1 release
-
-Three main Docker configurations:
-- `dependencies/godot-asset-optimizer-project/`: Asset optimization service
-- `dependencies/godot-runner/`: Godot explorer runner
-- `dependencies/crdt-runner/`: CRDT generation service
-
-## Key Implementation Details
-
-### Godot Integration
-- Godot runs in headless mode using Xvfb virtual display
-- Communicates via file system and exit codes
-- Timeout handling for long-running operations
-
-### Queue Processing
-- Messages contain deployment entity IDs and content server URLs
-- Supports both memory queue (for testing) and AWS SQS
-- Automatic retry and error handling
+Multi-architecture builds (AMD64/ARM64) in `dependencies/`:
+- `godot-asset-optimizer-project/`: Godot 4.5.1 (dclexplorer fork for AMD64, official for ARM64)
+- `godot-runner/`: Godot 4.4.1 (Decentraland fork for AMD64, official for ARM64)
+- `crdt-runner/`: Node.js only (no Godot)
 
-### Storage Abstraction
-- Supports both S3 and local file system storage
-- Consistent interface via `IStorageComponent`
+Godot runs headless using Xvfb virtual display.
 
-### Testing
-- Unit tests in `test/unit/`
-- Integration tests in `test/integration/`
-- Component mocking via `test/components.ts`
+## Adding a New Runner
 
-## Common Development Tasks
+1. Create directory in `src/runners/`
+2. Implement async function matching signature: `(components, job, message) => Promise<void>`
+3. Add to `validProcessMethods` array in `src/service.ts`
+4. Add case in main processing switch statement
 
-### Adding a New Runner
-1. Create new directory in `src/runners/`
-2. Implement runner function matching signature in `src/service.ts`
-3. Add to `validProcessMethods` array
-4. Wire in main processing loop
-
-### Debugging Docker Builds
-```bash
-# Check architecture-specific build
-docker buildx build --platform linux/arm64 -f dependencies/godot-optimizer/Dockerfile .
-
-# Run with entrypoint override for debugging
-docker run --rm --entrypoint /bin/bash -it godot-optimizer:latest
-
-# Check Godot installation
-docker run --rm --entrypoint /usr/local/bin/godot godot-optimizer:latest --version
-```
+## Entity ID Resolution
 
-### Working with Entity IDs
-The service supports both direct entity IDs and pointer resolution. If an entity ID contains a comma, it's treated as a pointer and resolved via the content server API.
+The service supports direct entity IDs and pointer resolution. If entity ID contains a comma, it's treated as a pointer and resolved via content server API.

dependencies/godot-asset-optimizer-project/entrypoint.sh

@@ -5,6 +5,6 @@ set -m
 
 /usr/bin/Xvfb -ac :99 -screen 0 1280x1024x24 > /dev/null 2>&1 &
 export DISPLAY=:99
-/usr/bin/node --enable-source-maps --trace-warnings --abort-on-uncaught-exception --unhandled-rejections=strict dist/index.js
+/usr/bin/node --enable-source-maps --trace-warnings --abort-on-uncaught-exception --unhandled-rejections=strict dist/index.js "$@"
 
 fg %1