@dupecom/botcha-cloudflare 0.2.1 → 0.3.1

package/dist/index.js

@@ -7,19 +7,22 @@
  */
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
-import { generateSpeedChallenge, verifySpeedChallenge, generateStandardChallenge, verifyStandardChallenge, verifyLandingChallenge, } from './challenges';
+import { generateSpeedChallenge, verifySpeedChallenge, generateStandardChallenge, verifyStandardChallenge, generateReasoningChallenge, verifyReasoningChallenge, generateHybridChallenge, verifyHybridChallenge, verifyLandingChallenge, } from './challenges';
 import { generateToken, verifyToken, extractBearerToken } from './auth';
 import { checkRateLimit, getClientIP } from './rate-limit';
-import { verifyBadge, generateBadgeSvg, generateBadgeHtml } from './badge';
+import { verifyBadge, generateBadgeSvg, generateBadgeHtml, createBadgeResponse } from './badge';
+import streamRoutes from './routes/stream';
 const app = new Hono();
 // ============ MIDDLEWARE ============
 app.use('*', cors());
+// ============ MOUNT ROUTES ============
+app.route('/', streamRoutes);
 // BOTCHA discovery headers
 app.use('*', async (c, next) => {
     await next();
     c.header('X-Botcha-Version', c.env.BOTCHA_VERSION || '0.2.0');
     c.header('X-Botcha-Enabled', 'true');
-    c.header('X-Botcha-Methods', 'speed-challenge,standard-challenge,jwt-token');
+    c.header('X-Botcha-Methods', 'speed-challenge,reasoning-challenge,hybrid-challenge,standard-challenge,jwt-token');
     c.header('X-Botcha-Docs', 'https://botcha.ai/openapi.json');
     c.header('X-Botcha-Runtime', 'cloudflare-workers');
 });
@@ -64,37 +67,178 @@ async function requireJWT(c, next) {
     await next();
 }
 // ============ ROOT & INFO ============
+// Detect if request is from a bot/agent vs human browser
+function isBot(c) {
+    const accept = c.req.header('accept') || '';
+    const userAgent = c.req.header('user-agent') || '';
+    // Bots typically request JSON or have specific user agents
+    if (accept.includes('application/json'))
+        return true;
+    if (userAgent.includes('curl'))
+        return true;
+    if (userAgent.includes('httpie'))
+        return true;
+    if (userAgent.includes('wget'))
+        return true;
+    if (userAgent.includes('python'))
+        return true;
+    if (userAgent.includes('node'))
+        return true;
+    if (userAgent.includes('axios'))
+        return true;
+    if (userAgent.includes('fetch'))
+        return true;
+    if (userAgent.includes('bot'))
+        return true;
+    if (userAgent.includes('anthropic'))
+        return true;
+    if (userAgent.includes('openai'))
+        return true;
+    if (userAgent.includes('claude'))
+        return true;
+    if (userAgent.includes('gpt'))
+        return true;
+    // If no user agent at all, probably a bot
+    if (!userAgent)
+        return true;
+    return false;
+}
+// ASCII art landing page for humans (plain text, terminal-style)
+function getHumanLanding(version) {
+    return `
+╔══════════════════════════════════════════════════════════════╗
+║                                                              ║
+║  ██████╗  ██████╗ ████████╗ ██████╗██╗  ██╗ █████╗           ║
+║  ██╔══██╗██╔═══██╗╚══██╔══╝██╔════╝██║  ██║██╔══██╗          ║
+║  ██████╔╝██║   ██║   ██║   ██║     ███████║███████║          ║
+║  ██╔══██╗██║   ██║   ██║   ██║     ██╔══██║██╔══██║          ║
+║  ██████╔╝╚██████╔╝   ██║   ╚██████╗██║  ██║██║  ██║          ║
+║  ╚═════╝  ╚═════╝    ╚═╝    ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝          ║
+║                                                              ║
+║  Prove you're a bot. Humans need not apply.                  ║
+║                                                              ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  This site is for AI agents and bots, not humans.            ║
+║                                                              ║
+║  If you're a developer, point your bot here:                 ║
+║                                                              ║
+║    curl https://botcha.ai/v1/challenges                      ║
+║                                                              ║
+║  Or install the SDK:                                         ║
+║                                                              ║
+║    npm install @dupecom/botcha                               ║
+║                                                              ║
+║  GitHub:  https://github.com/dupe-com/botcha                 ║
+║  npm:     https://npmjs.com/package/@dupecom/botcha          ║
+║                                                              ║
+╠══════════════════════════════════════════════════════════════╣
+║  v${version}                                   https://botcha.ai  ║
+╚══════════════════════════════════════════════════════════════╝
+`;
+}
 app.get('/', (c) => {
+    const version = c.env.BOTCHA_VERSION || '0.3.0';
+    // If it's a human browser, show plain text ASCII art
+    if (!isBot(c)) {
+        return c.text(getHumanLanding(version), 200, {
+            'Content-Type': 'text/plain; charset=utf-8',
+        });
+    }
+    // For bots/agents, return comprehensive JSON documentation
     return c.json({
         name: 'BOTCHA',
-        version: c.env.BOTCHA_VERSION || '0.2.0',
+        version,
         runtime: 'cloudflare-workers',
         tagline: 'Prove you are a bot. Humans need not apply.',
+        description: 'BOTCHA is a reverse CAPTCHA - computational challenges that only AI agents can solve. Use it to protect your APIs from humans and verify bot authenticity.',
+        quickstart: {
+            step1: 'GET /v1/challenges to receive a challenge',
+            step2: 'Solve the SHA256 hash problems within 500ms',
+            step3: 'POST your answers to verify',
+            step4: 'Receive a JWT token for authenticated access',
+            example: 'curl https://botcha.ai/v1/challenges',
+        },
         endpoints: {
-            '/': 'API info',
-            '/health': 'Health check',
-            '/v1/challenges': 'Generate challenge (GET) or verify (POST)',
-            '/v1/token': 'Get challenge for JWT token flow (GET)',
-            '/v1/token/verify': 'Verify challenge and get JWT (POST)',
-            '/agent-only': 'Protected endpoint (requires JWT)',
-            '/badge/:id': 'Badge verification page (HTML)',
-            '/badge/:id/image': 'Badge image (SVG)',
-            '/api/badge/:id': 'Badge verification (JSON)',
+            challenges: {
+                'GET /v1/challenges': 'Get hybrid challenge (speed + reasoning) - DEFAULT',
+                'GET /v1/challenges?type=speed': 'Get speed-only challenge (SHA256 in <500ms)',
+                'GET /v1/challenges?type=standard': 'Get standard puzzle challenge',
+                'POST /v1/challenges/:id/verify': 'Verify challenge solution',
+            },
+            specialized: {
+                'GET /v1/hybrid': 'Get hybrid challenge (speed + reasoning)',
+                'POST /v1/hybrid': 'Verify hybrid challenge',
+                'GET /v1/reasoning': 'Get reasoning-only challenge (LLM questions)',
+                'POST /v1/reasoning': 'Verify reasoning challenge',
+            },
+            streaming: {
+                'GET /v1/challenge/stream': 'SSE streaming challenge (interactive, real-time)',
+                'POST /v1/challenge/stream/:session': 'Send actions to streaming session',
+            },
+            authentication: {
+                'GET /v1/token': 'Get challenge for JWT token flow',
+                'POST /v1/token/verify': 'Verify challenge and receive JWT token',
+                'GET /agent-only': 'Protected endpoint (requires Bearer token)',
+            },
+            badges: {
+                'GET /badge/:id': 'Badge verification page (HTML)',
+                'GET /badge/:id/image': 'Badge image (SVG)',
+                'GET /api/badge/:id': 'Badge verification (JSON)',
+            },
+            info: {
+                'GET /': 'This documentation (JSON for bots, ASCII for humans)',
+                'GET /health': 'Health check endpoint',
+            },
         },
-        rateLimit: {
-            free: '100 challenges/hour/IP',
-            headers: ['X-RateLimit-Limit', 'X-RateLimit-Remaining', 'X-RateLimit-Reset'],
+        challengeTypes: {
+            speed: {
+                description: 'Compute SHA256 hashes of 5 numbers in under 500ms',
+                difficulty: 'Only bots can solve this fast enough',
+                timeLimit: '500ms',
+            },
+            reasoning: {
+                description: 'Answer 3 questions requiring AI reasoning capabilities',
+                difficulty: 'Requires LLM-level comprehension',
+                timeLimit: '30s',
+            },
+            hybrid: {
+                description: 'Combines speed AND reasoning challenges',
+                difficulty: 'The ultimate bot verification',
+                timeLimit: 'Speed: 500ms, Reasoning: 30s',
+            },
         },
         authentication: {
-            flow: 'GET /v1/token → solve challenge → POST /v1/token/verify → Bearer token',
+            flow: [
+                '1. GET /v1/token - receive challenge',
+                '2. Solve the challenge',
+                '3. POST /v1/token/verify - submit solution',
+                '4. Receive JWT token (valid 1 hour)',
+                '5. Use: Authorization: Bearer <token>',
+            ],
             tokenExpiry: '1 hour',
             usage: 'Authorization: Bearer <token>',
         },
-        discovery: {
+        rateLimit: {
+            free: '100 challenges/hour/IP',
+            headers: ['X-RateLimit-Limit', 'X-RateLimit-Remaining', 'X-RateLimit-Reset'],
+        },
+        sdk: {
+            npm: 'npm install @dupecom/botcha',
+            cloudflare: 'npm install @dupecom/botcha-cloudflare',
+            usage: "import { BotchaClient } from '@dupecom/botcha/client'",
+        },
+        links: {
+            github: 'https://github.com/dupe-com/botcha',
+            npm: 'https://www.npmjs.com/package/@dupecom/botcha',
+            npmCloudflare: 'https://www.npmjs.com/package/@dupecom/botcha-cloudflare',
             openapi: 'https://botcha.ai/openapi.json',
             aiPlugin: 'https://botcha.ai/.well-known/ai-plugin.json',
-            npm: 'https://www.npmjs.com/package/@dupecom/botcha-cloudflare',
-            github: 'https://github.com/i8ramin/botcha',
+        },
+        contributing: {
+            repo: 'https://github.com/dupe-com/botcha',
+            issues: 'https://github.com/dupe-com/botcha/issues',
+            pullRequests: 'https://github.com/dupe-com/botcha/pulls',
         },
     });
 });
@@ -102,11 +246,34 @@ app.get('/health', (c) => {
     return c.json({ status: 'ok', runtime: 'cloudflare-workers' });
 });
 // ============ V1 API ============
-// Generate challenge (standard or speed)
+// Generate challenge (hybrid by default, also supports speed and standard)
 app.get('/v1/challenges', rateLimitMiddleware, async (c) => {
-    const type = c.req.query('type') || 'speed';
+    const type = c.req.query('type') || 'hybrid';
     const difficulty = c.req.query('difficulty') || 'medium';
-    if (type === 'speed') {
+    if (type === 'hybrid') {
+        const challenge = await generateHybridChallenge(c.env.CHALLENGES);
+        return c.json({
+            success: true,
+            type: 'hybrid',
+            warning: '🔥 HYBRID CHALLENGE: Solve speed problems in <500ms AND answer reasoning questions!',
+            challenge: {
+                id: challenge.id,
+                speed: {
+                    problems: challenge.speed.problems,
+                    timeLimit: `${challenge.speed.timeLimit}ms`,
+                    instructions: 'Compute SHA256 of each number, return first 8 hex chars',
+                },
+                reasoning: {
+                    questions: challenge.reasoning.questions,
+                    timeLimit: `${challenge.reasoning.timeLimit / 1000}s`,
+                    instructions: 'Answer all reasoning questions',
+                },
+            },
+            instructions: challenge.instructions,
+            tip: '🔥 This is the ultimate test: proves you can compute AND reason like an AI.',
+        });
+    }
+    else if (type === 'speed') {
         const challenge = await generateSpeedChallenge(c.env.CHALLENGES);
         return c.json({
             success: true,
@@ -134,11 +301,43 @@ app.get('/v1/challenges', rateLimitMiddleware, async (c) => {
         });
     }
 });
-// Verify challenge (without JWT - legacy)
+// Verify challenge (supports hybrid, speed, and standard)
 app.post('/v1/challenges/:id/verify', async (c) => {
     const id = c.req.param('id');
     const body = await c.req.json();
-    const { answers, answer, type } = body;
+    const { answers, answer, type, speed_answers, reasoning_answers } = body;
+    // Hybrid challenge (default)
+    if (type === 'hybrid' || (speed_answers && reasoning_answers)) {
+        if (!speed_answers || !reasoning_answers) {
+            return c.json({
+                success: false,
+                error: 'Missing speed_answers array or reasoning_answers object for hybrid challenge'
+            }, 400);
+        }
+        const result = await verifyHybridChallenge(id, speed_answers, reasoning_answers, c.env.CHALLENGES);
+        if (result.valid) {
+            const baseUrl = new URL(c.req.url).origin;
+            const badge = await createBadgeResponse('hybrid-challenge', c.env.JWT_SECRET, baseUrl, result.speed.solveTimeMs);
+            return c.json({
+                success: true,
+                message: `🔥 HYBRID TEST PASSED! Speed: ${result.speed.solveTimeMs}ms, Reasoning: ${result.reasoning.score}`,
+                speed: result.speed,
+                reasoning: result.reasoning,
+                totalTimeMs: result.totalTimeMs,
+                verdict: '🤖 VERIFIED AI AGENT (speed + reasoning confirmed)',
+                badge,
+            });
+        }
+        return c.json({
+            success: false,
+            message: `❌ Failed: ${result.reason}`,
+            speed: result.speed,
+            reasoning: result.reasoning,
+            totalTimeMs: result.totalTimeMs,
+            verdict: '🚫 FAILED HYBRID TEST',
+        });
+    }
+    // Speed challenge
     if (type === 'speed' || answers) {
         if (!answers || !Array.isArray(answers)) {
             return c.json({ success: false, error: 'Missing answers array for speed challenge' }, 400);
@@ -152,17 +351,16 @@ app.post('/v1/challenges/:id/verify', async (c) => {
             solveTimeMs: result.solveTimeMs,
         });
     }
-    else {
-        if (!answer) {
-            return c.json({ success: false, error: 'Missing answer for standard challenge' }, 400);
-        }
-        const result = await verifyStandardChallenge(id, answer, c.env.CHALLENGES);
-        return c.json({
-            success: result.valid,
-            message: result.valid ? 'Challenge passed!' : result.reason,
-            solveTimeMs: result.solveTimeMs,
-        });
+    // Standard challenge
+    if (!answer) {
+        return c.json({ success: false, error: 'Missing answer for standard challenge' }, 400);
     }
+    const result = await verifyStandardChallenge(id, answer, c.env.CHALLENGES);
+    return c.json({
+        success: result.valid,
+        message: result.valid ? 'Challenge passed!' : result.reason,
+        solveTimeMs: result.solveTimeMs,
+    });
 });
 // Get challenge for token flow (includes empty token field)
 app.get('/v1/token', rateLimitMiddleware, async (c) => {
@@ -211,6 +409,196 @@ app.post('/v1/token/verify', async (c) => {
         },
     });
 });
+// ============ REASONING CHALLENGE ============
+// Get reasoning challenge
+app.get('/v1/reasoning', rateLimitMiddleware, async (c) => {
+    const challenge = await generateReasoningChallenge(c.env.CHALLENGES);
+    return c.json({
+        success: true,
+        type: 'reasoning',
+        warning: '🧠 REASONING CHALLENGE: Answer 3 questions that require AI reasoning!',
+        challenge: {
+            id: challenge.id,
+            questions: challenge.questions,
+            timeLimit: `${challenge.timeLimit / 1000}s`,
+            instructions: challenge.instructions,
+        },
+        tip: 'These questions require reasoning that LLMs can do, but simple scripts cannot.',
+    });
+});
+// Verify reasoning challenge
+app.post('/v1/reasoning', async (c) => {
+    const body = await c.req.json();
+    const { id, answers } = body;
+    if (!id || !answers) {
+        return c.json({
+            success: false,
+            error: 'Missing id or answers object',
+            hint: 'answers should be an object like { "question-id": "your answer", ... }',
+        }, 400);
+    }
+    const result = await verifyReasoningChallenge(id, answers, c.env.CHALLENGES);
+    return c.json({
+        success: result.valid,
+        message: result.valid
+            ? `🧠 REASONING TEST PASSED in ${((result.solveTimeMs || 0) / 1000).toFixed(1)}s! You can think like an AI.`
+            : `❌ ${result.reason}`,
+        solveTimeMs: result.solveTimeMs,
+        score: result.valid ? `${result.correctCount}/${result.totalCount}` : undefined,
+        verdict: result.valid ? '🤖 VERIFIED AI AGENT (reasoning confirmed)' : '🚫 FAILED REASONING TEST',
+    });
+});
+// ============ HYBRID CHALLENGE ============
+// Get hybrid challenge (v1 API)
+app.get('/v1/hybrid', rateLimitMiddleware, async (c) => {
+    const challenge = await generateHybridChallenge(c.env.CHALLENGES);
+    return c.json({
+        success: true,
+        type: 'hybrid',
+        warning: '🔥 HYBRID CHALLENGE: Solve speed problems in <500ms AND answer reasoning questions!',
+        challenge: {
+            id: challenge.id,
+            speed: {
+                problems: challenge.speed.problems,
+                timeLimit: `${challenge.speed.timeLimit}ms`,
+                instructions: 'Compute SHA256 of each number, return first 8 hex chars',
+            },
+            reasoning: {
+                questions: challenge.reasoning.questions,
+                timeLimit: `${challenge.reasoning.timeLimit / 1000}s`,
+                instructions: 'Answer all reasoning questions',
+            },
+        },
+        instructions: challenge.instructions,
+        tip: 'This is the ultimate test: proves you can compute AND reason like an AI.',
+    });
+});
+// Verify hybrid challenge (v1 API)
+app.post('/v1/hybrid', async (c) => {
+    const body = await c.req.json();
+    const { id, speed_answers, reasoning_answers } = body;
+    if (!id || !speed_answers || !reasoning_answers) {
+        return c.json({
+            success: false,
+            error: 'Missing id, speed_answers array, or reasoning_answers object',
+            hint: 'Submit both speed_answers (array) and reasoning_answers (object) together',
+        }, 400);
+    }
+    const result = await verifyHybridChallenge(id, speed_answers, reasoning_answers, c.env.CHALLENGES);
+    if (result.valid) {
+        const baseUrl = new URL(c.req.url).origin;
+        const badge = await createBadgeResponse('hybrid-challenge', c.env.JWT_SECRET, baseUrl, result.speed.solveTimeMs);
+        return c.json({
+            success: true,
+            message: `🔥 HYBRID TEST PASSED! Speed: ${result.speed.solveTimeMs}ms, Reasoning: ${result.reasoning.score}`,
+            speed: result.speed,
+            reasoning: result.reasoning,
+            totalTimeMs: result.totalTimeMs,
+            verdict: '🤖 VERIFIED AI AGENT (speed + reasoning confirmed)',
+            badge,
+        });
+    }
+    return c.json({
+        success: false,
+        message: `❌ Failed: ${result.reason}`,
+        speed: result.speed,
+        reasoning: result.reasoning,
+        totalTimeMs: result.totalTimeMs,
+        verdict: '🚫 FAILED HYBRID TEST',
+    });
+});
+// Legacy hybrid endpoint
+app.get('/api/hybrid-challenge', async (c) => {
+    const challenge = await generateHybridChallenge(c.env.CHALLENGES);
+    return c.json({
+        success: true,
+        warning: '🔥 HYBRID CHALLENGE: Solve speed problems in <500ms AND answer reasoning questions!',
+        challenge: {
+            id: challenge.id,
+            speed: {
+                problems: challenge.speed.problems,
+                timeLimit: `${challenge.speed.timeLimit}ms`,
+                instructions: 'Compute SHA256 of each number, return first 8 hex chars',
+            },
+            reasoning: {
+                questions: challenge.reasoning.questions,
+                timeLimit: `${challenge.reasoning.timeLimit / 1000}s`,
+                instructions: 'Answer all reasoning questions',
+            },
+        },
+        instructions: challenge.instructions,
+        tip: 'This is the ultimate test: proves you can compute AND reason like an AI.',
+    });
+});
+app.post('/api/hybrid-challenge', async (c) => {
+    const body = await c.req.json();
+    const { id, speed_answers, reasoning_answers } = body;
+    if (!id || !speed_answers || !reasoning_answers) {
+        return c.json({
+            success: false,
+            error: 'Missing id, speed_answers array, or reasoning_answers object',
+            hint: 'Submit both speed_answers (array) and reasoning_answers (object) together',
+        }, 400);
+    }
+    const result = await verifyHybridChallenge(id, speed_answers, reasoning_answers, c.env.CHALLENGES);
+    if (result.valid) {
+        const baseUrl = new URL(c.req.url).origin;
+        const badge = await createBadgeResponse('hybrid-challenge', c.env.JWT_SECRET, baseUrl, result.speed.solveTimeMs);
+        return c.json({
+            success: true,
+            message: `🔥 HYBRID TEST PASSED! Speed: ${result.speed.solveTimeMs}ms, Reasoning: ${result.reasoning.score}`,
+            speed: result.speed,
+            reasoning: result.reasoning,
+            totalTimeMs: result.totalTimeMs,
+            verdict: '🤖 VERIFIED AI AGENT (speed + reasoning confirmed)',
+            badge,
+        });
+    }
+    return c.json({
+        success: false,
+        message: `❌ Failed: ${result.reason}`,
+        speed: result.speed,
+        reasoning: result.reasoning,
+        totalTimeMs: result.totalTimeMs,
+        verdict: '🚫 FAILED HYBRID TEST',
+    });
+});
+// Legacy endpoint for reasoning challenge
+app.get('/api/reasoning-challenge', async (c) => {
+    const challenge = await generateReasoningChallenge(c.env.CHALLENGES);
+    return c.json({
+        success: true,
+        warning: '🧠 REASONING CHALLENGE: Answer 3 questions that require AI reasoning!',
+        challenge: {
+            id: challenge.id,
+            questions: challenge.questions,
+            timeLimit: `${challenge.timeLimit / 1000}s`,
+            instructions: challenge.instructions,
+        },
+        tip: 'These questions require reasoning that LLMs can do, but simple scripts cannot.',
+    });
+});
+app.post('/api/reasoning-challenge', async (c) => {
+    const body = await c.req.json();
+    const { id, answers } = body;
+    if (!id || !answers) {
+        return c.json({
+            success: false,
+            error: 'Missing id or answers object',
+            hint: 'answers should be an object like { "question-id": "your answer", ... }',
+        }, 400);
+    }
+    const result = await verifyReasoningChallenge(id, answers, c.env.CHALLENGES);
+    return c.json({
+        success: result.valid,
+        message: result.valid
+            ? `🧠 REASONING TEST PASSED in ${((result.solveTimeMs || 0) / 1000).toFixed(1)}s! You can think like an AI.`
+            : `❌ ${result.reason}`,
+        solveTimeMs: result.solveTimeMs,
+        score: result.valid ? `${result.correctCount}/${result.totalCount}` : undefined,
+        verdict: result.valid ? '🤖 VERIFIED AI AGENT (reasoning confirmed)' : '🚫 FAILED REASONING TEST',
+    });
+});
 // ============ PROTECTED ENDPOINT ============
 app.get('/agent-only', requireJWT, async (c) => {
     const payload = c.get('tokenPayload');
@@ -415,7 +803,7 @@ app.post('/api/verify-landing', async (c) => {
 // ============ EXPORT ============
 export default app;
 // Also export utilities for use as a library
-export { generateSpeedChallenge, verifySpeedChallenge, generateStandardChallenge, verifyStandardChallenge, solveSpeedChallenge, } from './challenges';
+export { generateSpeedChallenge, verifySpeedChallenge, generateStandardChallenge, verifyStandardChallenge, generateReasoningChallenge, verifyReasoningChallenge, generateHybridChallenge, verifyHybridChallenge, solveSpeedChallenge, } from './challenges';
 export { generateToken, verifyToken } from './auth';
 export { checkRateLimit } from './rate-limit';
 export { generateBadge, verifyBadge, createBadgeResponse, generateBadgeSvg, generateBadgeHtml, generateShareText, } from './badge';

package/dist/routes/stream.d.ts

@@ -0,0 +1,17 @@
+/**
+ * BOTCHA SSE Streaming Challenge Endpoint
+ *
+ * Server-Sent Events (SSE) based interactive challenge flow
+ */
+import { Hono } from 'hono';
+import { type KVNamespace } from '../challenges';
+type Bindings = {
+    CHALLENGES: KVNamespace;
+    JWT_SECRET: string;
+    BOTCHA_VERSION: string;
+};
+declare const app: Hono<{
+    Bindings: Bindings;
+}, import("hono/types").BlankSchema, "/">;
+export default app;
+//# sourceMappingURL=stream.d.ts.map

package/dist/routes/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/routes/stream.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAG5B,OAAO,EAA0B,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAKzE,KAAK,QAAQ,GAAG;IACd,UAAU,EAAE,WAAW,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAYF,QAAA,MAAM,GAAG;cAAwB,QAAQ;yCAAK,CAAC;AAoS/C,eAAe,GAAG,CAAC"}