@motiadev/adapter-redis-cron 0.8.2-beta.140-709523

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## [0.1.0] - 2025-10-22
+
+### Added
+- Initial release of Redis cron adapter for Motia
+- Distributed locking to prevent duplicate cron job executions
+- Automatic TTL for lock expiration
+- Lock renewal support for long-running jobs
+- Health check functionality
+- Configurable retry logic for lock acquisition
+- Instance tracking for monitoring
+- Graceful shutdown with automatic lock cleanup
+- Full TypeScript support with type definitions
+- Comprehensive documentation and examples
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Motia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,265 @@
+# @motiadev/adapter-redis-cron
+
+Redis cron adapter for Motia framework, enabling distributed cron job coordination to prevent duplicate executions across multiple instances.
+
+## Installation
+
+```bash
+npm install @motiadev/adapter-redis-cron
+```
+
+## Usage
+
+Configure the Redis cron adapter in your `motia.config.ts`:
+
+```typescript
+import { config } from '@motiadev/core'
+import { RedisCronAdapter } from '@motiadev/adapter-redis-cron'
+
+export default config({
+  adapters: {
+    cron: new RedisCronAdapter({
+      host: process.env.REDIS_HOST || 'localhost',
+      port: parseInt(process.env.REDIS_PORT || '6379'),
+      password: process.env.REDIS_PASSWORD,
+      keyPrefix: 'motia:cron:lock:',
+      lockTTL: 300000,
+      instanceId: process.env.INSTANCE_ID || undefined,
+    }),
+  },
+})
+```
+
+## Configuration Options
+
+### RedisCronAdapterConfig
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `host` | `string` | `'localhost'` | Redis server host |
+| `port` | `number` | `6379` | Redis server port |
+| `password` | `string` | `undefined` | Redis authentication password |
+| `username` | `string` | `undefined` | Redis authentication username |
+| `database` | `number` | `0` | Redis database number |
+| `keyPrefix` | `string` | `'motia:cron:lock:'` | Prefix for all lock keys |
+| `lockTTL` | `number` | `300000` | Lock time-to-live in milliseconds (5 minutes) |
+| `lockRetryDelay` | `number` | `1000` | Delay between lock retry attempts in milliseconds |
+| `lockRetryAttempts` | `number` | `0` | Number of times to retry acquiring a lock |
+| `instanceId` | `string` | Auto-generated UUID | Unique identifier for this instance |
+| `enableHealthCheck` | `boolean` | `true` | Whether to perform periodic health checks |
+| `socket.reconnectStrategy` | `function` | Auto-retry | Custom reconnection strategy |
+| `socket.connectTimeout` | `number` | `10000` | Connection timeout in milliseconds |
+
+## How It Works
+
+When running multiple instances of a Motia application, each instance schedules the same cron jobs. Without coordination, this leads to duplicate executions. The Redis Cron Adapter solves this using distributed locking:
+
+1. **Job Scheduling**: All instances schedule cron jobs normally
+2. **Lock Acquisition**: When a cron job triggers, the instance attempts to acquire a distributed lock
+3. **Execution**: Only the instance that successfully acquires the lock executes the job
+4. **Lock Release**: After execution completes (or fails), the lock is released
+5. **TTL Protection**: Locks have a TTL to prevent deadlocks if an instance crashes
+
+## Execution Flow
+
+```
+Instance 1              Instance 2              Instance 3
+    |                       |                       |
+    | Cron triggers         | Cron triggers         | Cron triggers
+    | (9:00 AM)             | (9:00 AM)             | (9:00 AM)
+    |                       |                       |
+    v                       v                       v
+acquireLock()          acquireLock()          acquireLock()
+    |                       |                       |
+    v                       v                       v
+┌─────────────────────────────────────────────────────┐
+│         Distributed Lock Store (Redis)              │
+│                                                     │
+│  Lock: daily-report                                │
+│  Owner: instance-1                                 │
+│  Acquired: 2025-10-22 09:00:00                    │
+│  Expires: 2025-10-22 09:05:00                     │
+└─────────────────────────────────────────────────────┘
+    |                       |                       |
+    v                       v                       v
+Lock acquired ✓        Lock failed ✗          Lock failed ✗
+    |                       |                       |
+    v                       |                       |
+Execute job             Skip execution         Skip execution
+    |                       |                       |
+    v                       |                       |
+releaseLock()              |                       |
+```
+
+## Features
+
+- **Distributed Locking**: Prevents duplicate cron job executions across instances
+- **Automatic TTL**: Locks expire automatically to prevent deadlocks
+- **Lock Renewal**: Support for renewing locks for long-running jobs
+- **Health Checks**: Monitor Redis connection health
+- **Retry Logic**: Configurable retry attempts for lock acquisition
+- **Instance Tracking**: Track which instance holds each lock
+- **Graceful Shutdown**: Automatically releases locks on shutdown
+
+## Key Namespacing
+
+The adapter uses the following key pattern:
+```
+{keyPrefix}{jobName}
+```
+
+For example:
+```
+motia:cron:lock:daily-report
+motia:cron:lock:cleanup-task
+motia:cron:lock:send-notifications
+```
+
+## Example Cron Step
+
+```typescript
+// steps/dailyReport/dailyReport.step.ts
+import { type Handlers } from './types'
+
+export const config = {
+  name: 'DailyReport',
+  cron: '0 9 * * *', // Run at 9 AM daily
+}
+
+export const handler: Handlers['DailyReport'] = async ({ logger }) => {
+  logger.info('Generating daily report')
+  
+  // This will only execute on ONE instance
+  // even if you have 10 instances running
+  
+  await generateReport()
+  await sendReport()
+  
+  logger.info('Daily report sent successfully')
+}
+```
+
+## Lock Renewal for Long-Running Jobs
+
+For cron jobs that may take longer than the lock TTL, implement lock renewal:
+
+```typescript
+export const handler: Handlers['LongRunningJob'] = async ({ logger }) => {
+  // Note: Lock renewal is handled internally by the cron handler
+  // You can configure a longer lockTTL in the adapter config
+  
+  logger.info('Starting long-running job')
+  
+  // Your long-running logic here
+  await processLargeDataset()
+  
+  logger.info('Long-running job completed')
+}
+```
+
+## Monitoring Active Locks
+
+To monitor which instances are executing cron jobs:
+
+```typescript
+import { RedisCronAdapter } from '@motiadev/adapter-redis-cron'
+
+const adapter = new RedisCronAdapter({
+  host: 'localhost',
+  port: 6379,
+})
+
+const activeLocks = await adapter.getActiveLocks()
+console.log('Active cron jobs:', activeLocks)
+```
+
+## Environment Variables
+
+```bash
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=your-password
+REDIS_DATABASE=0
+CRON_KEY_PREFIX=motia:cron:lock:
+CRON_LOCK_TTL=300000
+INSTANCE_ID=instance-1
+```
+
+## Lock TTL Selection
+
+Choose the lock TTL based on your job execution times:
+
+- **Short Jobs** (< 1 minute): Use 60000ms (1 minute) TTL
+- **Medium Jobs** (1-5 minutes): Use 300000ms (5 minutes) TTL
+- **Long Jobs** (> 5 minutes): Use 600000ms+ (10+ minutes) TTL
+
+## Performance Considerations
+
+- **Lock Overhead**: Redis lock acquisition adds ~2-5ms overhead per cron trigger (negligible)
+- **Scalability**: Scales linearly with number of unique cron jobs, not number of instances
+- **Network Latency**: Consider network latency between app and Redis
+- **TTL Settings**: Set appropriate TTL values based on job execution times
+
+## Edge Cases
+
+### Instance Crashes
+
+If an instance crashes while holding a lock, the lock will expire after the TTL, allowing another instance to execute the job. This provides automatic recovery.
+
+### Clock Skew
+
+Different instances might have slightly different system clocks, causing cron jobs to trigger at slightly different times. The lock mechanism ensures only one execution regardless of timing differences.
+
+### Redis Unavailability
+
+If Redis is unavailable, all instances will fail to acquire locks and no cron jobs will execute. This is a fail-safe behavior to prevent duplicates.
+
+## Development vs Production
+
+### Development
+
+For development environments where horizontal scaling is not needed:
+- Omit the `cron` adapter from configuration
+- Cron jobs will execute normally without distributed locking
+- Reduces external dependencies during development
+
+### Production
+
+For production with multiple instances:
+- Always configure a cron adapter
+- Use managed Redis services (AWS ElastiCache, etc.) for high availability
+- Set appropriate lock TTLs based on job execution times
+- Monitor active locks to ensure proper coordination
+
+## Troubleshooting
+
+### Cron Jobs Not Executing
+
+If no cron jobs are executing:
+1. Verify Redis is accessible from all instances
+2. Check Redis connection credentials
+3. Review instance logs for lock acquisition errors
+4. Verify cron expressions are valid
+5. Check Redis memory and connection limits
+
+### Duplicate Executions
+
+If you see duplicate executions:
+1. Verify all instances use the same Redis instance
+2. Check that cron adapter is properly configured
+3. Review lock TTL settings (may be too short)
+4. Check for clock skew between instances
+5. Monitor Redis connection stability
+
+### Lock Contention
+
+If locks are frequently contended:
+1. Review cron schedules to avoid overlapping jobs
+2. Consider staggering job execution times
+3. Increase lock retry attempts if appropriate
+4. Monitor Redis performance
+
+## License
+
+MIT
+

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { RedisCronAdapter } from './redis-cron-adapter';
+export type { RedisCronAdapterConfig } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,YAAY,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCronAdapter = void 0;
+var redis_cron_adapter_1 = require("./redis-cron-adapter");
+Object.defineProperty(exports, "RedisCronAdapter", { enumerable: true, get: function () { return redis_cron_adapter_1.RedisCronAdapter; } });

package/dist/redis-cron-adapter.d.ts

@@ -0,0 +1,24 @@
+import type { CronAdapter, CronLock, CronLockInfo } from '@motiadev/core';
+import type { RedisCronAdapterConfig } from './types';
+export declare class RedisCronAdapter implements CronAdapter {
+    private client;
+    private keyPrefix;
+    private lockTTL;
+    private lockRetryDelay;
+    private lockRetryAttempts;
+    private instanceId;
+    private enableHealthCheck;
+    private connected;
+    constructor(config: RedisCronAdapterConfig);
+    private connect;
+    private ensureConnected;
+    private makeKey;
+    acquireLock(jobName: string, ttl?: number): Promise<CronLock | null>;
+    releaseLock(lock: CronLock): Promise<void>;
+    renewLock(lock: CronLock, ttl: number): Promise<boolean>;
+    isHealthy(): Promise<boolean>;
+    shutdown(): Promise<void>;
+    getActiveLocks(): Promise<CronLockInfo[]>;
+    private scanKeys;
+}
+//# sourceMappingURL=redis-cron-adapter.d.ts.map

package/dist/redis-cron-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-cron-adapter.d.ts","sourceRoot":"","sources":["../src/redis-cron-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAGzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAErD,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,iBAAiB,CAAQ;IACjC,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,SAAS,CAAQ;gBAEb,MAAM,EAAE,sBAAsB;YA+C5B,OAAO;YAWP,eAAe;IAM7B,OAAO,CAAC,OAAO;IAIT,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IA8CpE,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B1C,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAwCxD,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAc7B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAyBzB,cAAc,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;YA2BjC,QAAQ;CAevB"}

package/dist/redis-cron-adapter.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCronAdapter = void 0;
+const redis_1 = require("redis");
+const uuid_1 = require("uuid");
+class RedisCronAdapter {
+    constructor(config) {
+        this.connected = false;
+        this.keyPrefix = config.keyPrefix || 'motia:cron:lock:';
+        this.lockTTL = config.lockTTL || 300000;
+        this.lockRetryDelay = config.lockRetryDelay || 1000;
+        this.lockRetryAttempts = config.lockRetryAttempts || 0;
+        this.instanceId = config.instanceId || `motia-${(0, uuid_1.v4)()}`;
+        this.enableHealthCheck = config.enableHealthCheck ?? true;
+        this.client = (0, redis_1.createClient)({
+            socket: {
+                host: config.host || 'localhost',
+                port: config.port || 6379,
+                reconnectStrategy: config.socket?.reconnectStrategy ||
+                    ((retries) => {
+                        if (retries > 10) {
+                            return new Error('Redis connection retry limit exceeded');
+                        }
+                        return Math.min(retries * 100, 3000);
+                    }),
+                connectTimeout: config.socket?.connectTimeout || 10000,
+            },
+            password: config.password,
+            username: config.username,
+            database: config.database || 0,
+        });
+        this.client.on('error', (err) => {
+            console.error('[Redis Cron] Client error:', err);
+        });
+        this.client.on('connect', () => {
+            this.connected = true;
+        });
+        this.client.on('disconnect', () => {
+            console.warn('[Redis Cron] Disconnected');
+            this.connected = false;
+        });
+        this.client.on('reconnecting', () => {
+            console.log('[Redis Cron] Reconnecting...');
+        });
+        this.connect();
+    }
+    async connect() {
+        if (!this.connected && !this.client.isOpen) {
+            try {
+                await this.client.connect();
+            }
+            catch (error) {
+                console.error('[Redis Cron] Failed to connect:', error);
+                throw error;
+            }
+        }
+    }
+    async ensureConnected() {
+        if (!this.client.isOpen) {
+            await this.connect();
+        }
+    }
+    makeKey(jobName) {
+        return `${this.keyPrefix}${jobName}`;
+    }
+    async acquireLock(jobName, ttl) {
+        await this.ensureConnected();
+        const lockTTL = ttl || this.lockTTL;
+        const lockId = (0, uuid_1.v4)();
+        const key = this.makeKey(jobName);
+        const now = Date.now();
+        const expiresAt = now + lockTTL;
+        const lock = {
+            jobName,
+            lockId,
+            acquiredAt: now,
+            expiresAt,
+            instanceId: this.instanceId,
+        };
+        const lockData = JSON.stringify(lock);
+        const result = await this.client.set(key, lockData, {
+            PX: lockTTL,
+            NX: true,
+        });
+        if (result === 'OK') {
+            return lock;
+        }
+        if (this.lockRetryAttempts > 0) {
+            for (let attempt = 0; attempt < this.lockRetryAttempts; attempt++) {
+                await new Promise((resolve) => setTimeout(resolve, this.lockRetryDelay));
+                const retryResult = await this.client.set(key, lockData, {
+                    PX: lockTTL,
+                    NX: true,
+                });
+                if (retryResult === 'OK') {
+                    return lock;
+                }
+            }
+        }
+        return null;
+    }
+    async releaseLock(lock) {
+        await this.ensureConnected();
+        const key = this.makeKey(lock.jobName);
+        const luaScript = `
+      local current = redis.call('GET', KEYS[1])
+      if not current then
+        return 0
+      end
+      
+      local lock = cjson.decode(current)
+      if lock.lockId == ARGV[1] and lock.instanceId == ARGV[2] then
+        return redis.call('DEL', KEYS[1])
+      end
+      
+      return 0
+    `;
+        try {
+            await this.client.eval(luaScript, {
+                keys: [key],
+                arguments: [lock.lockId, lock.instanceId],
+            });
+        }
+        catch (error) {
+            console.error('[Redis Cron] Error releasing lock:', error);
+        }
+    }
+    async renewLock(lock, ttl) {
+        await this.ensureConnected();
+        const key = this.makeKey(lock.jobName);
+        const now = Date.now();
+        const expiresAt = now + ttl;
+        const renewedLock = {
+            ...lock,
+            expiresAt,
+        };
+        const luaScript = `
+      local current = redis.call('GET', KEYS[1])
+      if not current then
+        return 0
+      end
+      
+      local lock = cjson.decode(current)
+      if lock.lockId == ARGV[1] and lock.instanceId == ARGV[2] then
+        redis.call('SET', KEYS[1], ARGV[3], 'PX', ARGV[4])
+        return 1
+      end
+      
+      return 0
+    `;
+        try {
+            const result = await this.client.eval(luaScript, {
+                keys: [key],
+                arguments: [lock.lockId, lock.instanceId, JSON.stringify(renewedLock), ttl.toString()],
+            });
+            return result === 1;
+        }
+        catch (error) {
+            console.error('[Redis Cron] Error renewing lock:', error);
+            return false;
+        }
+    }
+    async isHealthy() {
+        if (!this.enableHealthCheck) {
+            return true;
+        }
+        try {
+            await this.ensureConnected();
+            const result = await this.client.ping();
+            return result === 'PONG';
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async shutdown() {
+        await this.ensureConnected();
+        const pattern = `${this.keyPrefix}*`;
+        const keys = await this.scanKeys(pattern);
+        for (const key of keys) {
+            const lockData = await this.client.get(key);
+            if (lockData) {
+                try {
+                    const lock = JSON.parse(lockData);
+                    if (lock.instanceId === this.instanceId) {
+                        await this.client.del(key);
+                    }
+                }
+                catch (error) {
+                    console.error('[Redis Cron] Error cleaning up lock during shutdown:', error);
+                }
+            }
+        }
+        if (this.client.isOpen) {
+            await this.client.quit();
+        }
+    }
+    async getActiveLocks() {
+        await this.ensureConnected();
+        const pattern = `${this.keyPrefix}*`;
+        const keys = await this.scanKeys(pattern);
+        const locks = [];
+        for (const key of keys) {
+            const lockData = await this.client.get(key);
+            if (lockData) {
+                try {
+                    const lock = JSON.parse(lockData);
+                    locks.push({
+                        jobName: lock.jobName,
+                        instanceId: lock.instanceId,
+                        acquiredAt: lock.acquiredAt,
+                        expiresAt: lock.expiresAt,
+                    });
+                }
+                catch (error) {
+                    console.error('[Redis Cron] Error parsing lock data:', error);
+                }
+            }
+        }
+        return locks;
+    }
+    async scanKeys(pattern) {
+        const keys = [];
+        let cursor = 0;
+        do {
+            const result = await this.client.scan(cursor, {
+                MATCH: pattern,
+                COUNT: 100,
+            });
+            cursor = result.cursor;
+            keys.push(...result.keys);
+        } while (cursor !== 0);
+        return keys;
+    }
+}
+exports.RedisCronAdapter = RedisCronAdapter;

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export interface RedisCronAdapterConfig {
+    host?: string;
+    port?: number;
+    password?: string;
+    username?: string;
+    database?: number;
+    keyPrefix?: string;
+    lockTTL?: number;
+    lockRetryDelay?: number;
+    lockRetryAttempts?: number;
+    instanceId?: string;
+    enableHealthCheck?: boolean;
+    socket?: {
+        reconnectStrategy?: (retries: number) => number | Error;
+        connectTimeout?: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,MAAM,CAAC,EAAE;QACP,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,KAAK,CAAA;QACvD,cAAc,CAAC,EAAE,MAAM,CAAA;KACxB,CAAA;CACF"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@motiadev/adapter-redis-cron",
+  "description": "Redis cron adapter for Motia framework, enabling distributed cron job coordination to prevent duplicate executions across multiple instances.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "version": "0.8.2-beta.140-709523",
+  "dependencies": {
+    "redis": "^4.7.0",
+    "uuid": "^11.1.0",
+    "@motiadev/core": "0.8.2-beta.140-709523"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  },
+  "peerDependencies": {
+    "@motiadev/core": "^0.8.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "lint": "biome check .",
+    "watch": "tsc --watch"
+  }
+}