bulltrackers-module 1.0.1002 → 1.0.1004

package/functions/api-v3/routes/computations.js

@@ -121,7 +121,7 @@ const createComputationsRouter = () => {
                 requestId: req.requestId || null,
                 createdAt: new Date().toISOString()
             };
-            await redis.set(VERIFY_TICKET_PREFIX + ticket, JSON.stringify(payload), 'EX', VERIFY_TICKET_TTL_SECONDS);
+            await redis.set(VERIFY_TICKET_PREFIX + ticket, JSON.stringify(payload), { ex: VERIFY_TICKET_TTL_SECONDS });
             const expiresAt = new Date(Date.now() + VERIFY_TICKET_TTL_SECONDS * 1000).toISOString();
             res.json({
                 success: true,
@@ -242,11 +242,11 @@ const createComputationsRouter = () => {
         }
     });
 
-    // POST /verify: Run verification sandbox (no GCS write). Returns staged results.
-    router.post('/verify', requireVerifiedUser, async (req, res, next) => {
-        try {
-            const userId = req.targetUserId;
-            const { code, name } = req.body || {};
+    // POST /verify: Run verification sandbox (no GCS write). Returns staged results.
+    router.post('/verify', requireVerifiedUser, async (req, res, next) => {
+        try {
+            const userId = req.targetUserId;
+            const { code, name } = req.body || {};
             if (!code || typeof code !== 'string') {
                 return res.status(400).json({ error: 'Missing or invalid "code"' });
             }
@@ -277,14 +277,15 @@ const createComputationsRouter = () => {
                 // non-fatal: allow verify with only static deps
             }
             const sandboxUrl = config.computationVerification?.url || '';
-            const sandboxResult = await callVerificationSandbox(sandboxUrl, { code, name, userId, userComputationNames }, { logger: req.services.logger || console });
-            const result = sandboxResult !== null
-                ? sandboxResult
-                : await runVerification(code, name, userId, { userComputationNames, logger: req.services.logger || console });
-            if (result.passed === true && req.services.db) {
-                writeComputationNotification(
-                    req.services.db,
-                    userId,
+            const sandboxResult = await callVerificationSandbox(sandboxUrl, { code, name, userId, userComputationNames }, { logger: req.services.logger || console });
+            const result = sandboxResult !== null
+                ? sandboxResult
+                : await runVerification(code, name, userId, { userComputationNames, logger: req.services.logger || console });
+            const codeHash = crypto.createHash('sha256').update(code).digest('hex');
+            if (result.passed === true && req.services.db) {
+                writeComputationNotification(
+                    req.services.db,
+                    userId,
                     'COMPUTATION_VERIFIED',
                     'Computation verified',
                     `"${name}" passed verification.`,
@@ -292,21 +293,51 @@ const createComputationsRouter = () => {
                     'success'
                 ).catch(() => { });
             }
-            res.json({
-                success: result.passed,
-                stages: result.stages,
-                passed: result.passed,
-                errors: result.errors || null,
-                errorCodes: result.errorCodes || null,
-                logOutput: result.logOutput || null,
-                origin: 'verification',
-                remainingVerifications: typeof remaining === 'number' ? remaining : undefined,
-                limit
-            });
-        } catch (error) {
-            next(error);
-        }
-    });
+            res.json({
+                success: result.passed,
+                stages: result.stages,
+                passed: result.passed,
+                errors: result.errors || null,
+                errorCodes: result.errorCodes || null,
+                codeHash,
+                resultSummary: result.resultSummary || null,
+                resultPreview: result.resultPreview || null,
+                logOutput: result.logOutput || null,
+                origin: 'verification',
+                remainingVerifications: typeof remaining === 'number' ? remaining : undefined,
+                limit
+            });
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    // GET /verification/status?name=... — latest verification status for a computation name
+    router.get('/verification/status', requireVerifiedUser, async (req, res, next) => {
+        try {
+            const userId = req.targetUserId;
+            const rawName = (req.query.name && String(req.query.name).trim()) || '';
+            if (!rawName) {
+                return res.status(400).json({ error: 'Missing or invalid "name"' });
+            }
+            if (!req.services.db) {
+                return res.status(503).json({ error: 'Verification status unavailable' });
+            }
+            const normalizedName = Manifest.normalize(rawName);
+            if (!normalizedName) {
+                return res.status(400).json({ error: 'Invalid computation name' });
+            }
+            const statusRef = req.services.db.collection('users').doc(userId)
+                .collection('verification_status').doc(normalizedName);
+            const snap = await statusRef.get();
+            if (!snap.exists) {
+                return res.status(404).json({ error: 'Verification status not found' });
+            }
+            return res.json({ success: true, data: snap.data() });
+        } catch (error) {
+            next(error);
+        }
+    });
 
     // POST /annotate-sql — stateless SQL annotation for a computation source (no writes).
     router.post('/annotate-sql', requireVerifiedUser, async (req, res, next) => {
@@ -715,8 +746,8 @@ const createComputationsRouter = () => {
     router.post('/upload', requireVerifiedUser, requireSubscription({ billingUrl: '/billing' }), async (req, res, next) => {
         try {
             const userId = req.targetUserId;
-            const { services } = req;
-            const { code, name, overwriteLast7Days } = req.body;
+            const { services } = req;
+            const { code, name, overwriteLast7Days } = req.body;
 
             if (!code || typeof code !== 'string') {
                 return res.status(400).json({ error: 'Missing or invalid "code"' });
@@ -737,9 +768,9 @@ const createComputationsRouter = () => {
                 }
             }
 
-            // Upload failure backoff: block if user is in exponential backoff from recent verification failures
-            const backoff = await checkUploadBackoff(userId);
-            if (backoff.blocked) {
+            // Upload failure backoff: block if user is in exponential backoff from recent verification failures
+            const backoff = await checkUploadBackoff(userId);
+            if (backoff.blocked) {
                 const retryAfter = backoff.retryAfterSeconds ?? 60;
                 res.setHeader('Retry-After', String(retryAfter));
                 return res.status(429).json({
@@ -749,57 +780,69 @@ const createComputationsRouter = () => {
                 });
             }
 
-            // Optional: stream verification progress via SSE (client then GET /computations/upload/stream/:id)
-            if (req.body.stream === true) {
-                const uploadSessionId = uuidv4();
-                const redis = getRedis();
-                if (redis) {
-                    await redis.set(UPLOAD_SESSION_PREFIX + uploadSessionId, userId, 'EX', UPLOAD_SESSION_TTL);
-                }
-                res.status(200).json({ uploadSessionId });
-                setImmediate(async () => {
-                    try {
-                        let userComputationNames = [];
-                        try {
-                            const ref = services.db.collection('users').doc(userId).collection('computations');
-                            const snap = await ref.get();
-                            snap.docs.forEach(d => {
-                                const n = d.data()?.name || d.id;
-                                if (n) userComputationNames.push(Manifest.normalize(n));
-                            });
-                        } catch (e) { /* non-fatal */ }
-                        const verifyResult = await runVerification(code, name, userId, {
-                            userComputationNames,
-                            logger: services.logger || console,
-                            uploadSessionId,
-                            onStageProgress: (sid, payload) => publishUploadStreamEvent(sid, payload)
-                        });
-                        if (verifyResult.passed !== true) {
-                            await recordUploadFailure(userId);
-                            publishUploadStreamEvent(uploadSessionId, { type: 'final', passed: false, stages: verifyResult.stages, errors: verifyResult.errors, errorCodes: verifyResult.errorCodes || null, origin: 'verification' });
-                            return;
-                        }
-                        let extractedConfig;
-                        try {
-                            extractedConfig = Manifest.extractConfig(code);
-                        } catch (e) {
-                            await recordUploadFailure(userId);
-                            publishUploadStreamEvent(uploadSessionId, { type: 'final', passed: false, error: `Config extraction failed: ${e.message}` });
-                            return;
-                        }
-                        if (!extractedConfig || typeof extractedConfig !== 'object') {
-                            await recordUploadFailure(userId);
-                            publishUploadStreamEvent(uploadSessionId, { type: 'final', passed: false, error: 'Config could not be extracted' });
-                            return;
-                        }
-                        const hash = crypto.createHash('sha256').update(code).digest('hex');
-                        const bucket = services.storage.bucket(config.codeBucket);
-                        const blobName = `blobs/${hash}.js`;
-                        const blob = bucket.file(blobName);
-                        const [exists] = await blob.exists();
-                        if (!exists) {
-                            await blob.save(code, {
-                                metadata: {
+            // Optional: stream verification progress via SSE (client then GET /computations/upload/stream/:id)
+            if (req.body.stream === true) {
+                const uploadSessionId = uuidv4();
+                const redis = getRedis();
+                if (redis) {
+                    await redis.set(UPLOAD_SESSION_PREFIX + uploadSessionId, userId, { ex: UPLOAD_SESSION_TTL });
+                }
+                res.status(200).json({ uploadSessionId });
+                setImmediate(async () => {
+                    try {
+                        if (!services.db) {
+                            publishUploadStreamEvent(uploadSessionId, {
+                                type: 'final',
+                                passed: false,
+                                error: 'Upload unavailable',
+                                origin: 'system'
+                            });
+                            return;
+                        }
+                        const normalizedName = Manifest.normalize(name);
+                        const codeHash = crypto.createHash('sha256').update(code).digest('hex');
+                        const statusRef = services.db.collection('users').doc(userId)
+                            .collection('verification_status').doc(normalizedName);
+                        const statusSnap = await statusRef.get();
+                        const statusData = statusSnap.exists ? statusSnap.data() : null;
+                        if (!statusData || statusData.lastHash !== codeHash) {
+                            publishUploadStreamEvent(uploadSessionId, {
+                                type: 'final',
+                                passed: false,
+                                error: 'Verification required. Please verify this computation before uploading.',
+                                origin: 'verification'
+                            });
+                            return;
+                        }
+                        publishUploadStreamEvent(uploadSessionId, {
+                            type: 'stage',
+                            stages: [{ id: 'verification', status: 'passed', message: 'Verified hash matched' }]
+                        });
+                        let extractedConfig;
+                        try {
+                            extractedConfig = Manifest.extractConfig(code);
+                        } catch (e) {
+                            await recordUploadFailure(userId);
+                            publishUploadStreamEvent(uploadSessionId, { type: 'final', passed: false, error: `Config extraction failed: ${e.message}` });
+                            return;
+                        }
+                        if (!extractedConfig || typeof extractedConfig !== 'object') {
+                            await recordUploadFailure(userId);
+                            publishUploadStreamEvent(uploadSessionId, { type: 'final', passed: false, error: 'Config could not be extracted' });
+                            return;
+                        }
+                        const hash = codeHash;
+                        const bucket = services.storage.bucket(config.codeBucket);
+                        const blobName = `blobs/${hash}.js`;
+                        const blob = bucket.file(blobName);
+                        publishUploadStreamEvent(uploadSessionId, {
+                            type: 'stage',
+                            stages: [{ id: 'upload', status: 'running', message: 'Uploading computation code' }]
+                        });
+                        const [exists] = await blob.exists();
+                        if (!exists) {
+                            await blob.save(code, {
+                                metadata: {
                                     contentType: 'application/javascript',
                                     cacheControl: 'public, max-age=31536000, immutable',
                                     metadata: { uploadedBy: userId, originalName: name, verifiedAt: new Date().toISOString() }
@@ -829,57 +872,50 @@ const createComputationsRouter = () => {
                             } else if (!currentData.status) dataToSet.status = 'paused';
                             t.set(userCompRef, dataToSet, { merge: true });
                         });
-                        await clearUploadFailure(userId);
-                        if (services.db) {
-                            writeComputationNotification(
-                                services.db,
-                                userId,
+                        await clearUploadFailure(userId);
+                        if (services.db) {
+                            writeComputationNotification(
+                                services.db,
+                                userId,
                                 'COMPUTATION_UPLOADED',
                                 'Computation uploaded',
                                 `"${name}" uploaded (${hash.substring(0, 8)}).`,
                                 { computationName: name, versionHash: hash },
                                 'success'
                             ).catch(() => { });
-                        }
-                        publishUploadStreamEvent(uploadSessionId, { type: 'final', passed: true, hash, computationId });
-                    } catch (e) {
-                        console.error('[Upload stream] background error:', e);
-                        if (uploadSessionId) {
+                        }
+                        publishUploadStreamEvent(uploadSessionId, {
+                            type: 'final',
+                            passed: true,
+                            hash,
+                            computationId
+                        });
+                    } catch (e) {
+                        console.error('[Upload stream] background error:', e);
+                        if (uploadSessionId) {
                             publishUploadStreamEvent(uploadSessionId, { type: 'final', passed: false, error: e.message });
                         }
                     }
                 });
                 return;
-            }
-
-            // Hard barrier: sandbox verification must pass before any GCS write or Firestore update
-            let userComputationNames = [];
-            try {
-                const ref = services.db.collection('users').doc(userId).collection('computations');
-                const snap = await ref.get();
-                snap.docs.forEach(d => {
-                    const n = d.data()?.name || d.id;
-                    if (n) userComputationNames.push(Manifest.normalize(n));
-                });
-            } catch (e) {
-                // non-fatal: allow upload with only static deps
-            }
-            const sandboxUrl = config.computationVerification?.url || '';
-            const sandboxResult = await callVerificationSandbox(sandboxUrl, { code, name, userId, userComputationNames }, { logger: services.logger || console });
-            const verifyResult = sandboxResult !== null
-                ? sandboxResult
-                : await runVerification(code, name, userId, { userComputationNames, logger: services.logger || console });
-            if (verifyResult.passed !== true) {
-                await recordUploadFailure(userId);
-                return res.status(422).json({
-                    error: 'Verification failed',
-                    message: 'Computation must pass sandbox verification before upload.',
-                    stages: verifyResult.stages,
-                    errors: verifyResult.errors || null,
-                    errorCodes: verifyResult.errorCodes || null,
-                    origin: 'verification'
-                });
-            }
+            }
+
+            // Hard barrier: sandbox verification must pass before any GCS write or Firestore update
+            if (!services.db) {
+                return res.status(503).json({ error: 'Upload unavailable' });
+            }
+            const normalizedName = Manifest.normalize(name);
+            const codeHash = crypto.createHash('sha256').update(code).digest('hex');
+            const statusRef = services.db.collection('users').doc(userId)
+                .collection('verification_status').doc(normalizedName);
+            const statusSnap = await statusRef.get();
+            const statusData = statusSnap.exists ? statusSnap.data() : null;
+            if (!statusData || statusData.lastHash !== codeHash) {
+                return res.status(422).json({
+                    error: 'Verification required',
+                    message: 'Computation must pass sandbox verification before upload (hash mismatch or missing verification).'
+                });
+            }
 
             // Extract config for schedule; fail upload if config cannot be parsed (scheduling metadata must be valid).
             let extractedConfig;
@@ -899,7 +935,7 @@ const createComputationsRouter = () => {
             }
 
             // Hash Code
-            const hash = crypto.createHash('sha256').update(code).digest('hex');
+            const hash = codeHash;
 
             // Write to GCS (CAS) — only reached after verification passed
             const bucket = services.storage.bucket(config.codeBucket);

package/functions/api-v3/services/verificationSandboxClient.js

@@ -45,7 +45,9 @@ async function callVerificationSandbox(sandboxUrl, payload, opts = {}) {
             passed: Boolean(body.passed),
             stages: Array.isArray(body.stages) ? body.stages : [],
             errors: body.errors ?? null,
-            errorCodes: Array.isArray(body.errorCodes) ? body.errorCodes : (body.errorCodes ?? null)
+            errorCodes: Array.isArray(body.errorCodes) ? body.errorCodes : (body.errorCodes ?? null),
+            resultSummary: body.resultSummary ?? null,
+            resultPreview: body.resultPreview ?? null
         };
     } catch (err) {
         logger.log('ERROR', '[VerificationSandbox] Request failed', { message: err.message, url: sandboxUrl });

package/functions/api-v3/testing/routes.integration.test.js

@@ -946,57 +946,65 @@ describe('Cross-Cutting', () => {
             'Content-Type': 'application/json',
         });
 
-        it('returns 422 and does not write to GCS when code fails verification (process.env)', async () => {
-            const res = await request(app)
-                .post('/computations/upload')
-                .set(auth())
-                .send({
-                    code: `module.exports = { config: { name: 'Evil', skills: [], requires: {} }, process(ctx) { return process.env; } };`,
-                    name: 'Evil',
-                });
-            expect(res.status).toBe(422);
-            expect(res.body.error).toBe('Verification failed');
-            expect(res.body.stages).toBeDefined();
-            expect(storage._saveCalls.length).toBe(0);
-        });
-
-        it('returns 422 and does not write to GCS when code fails verification (require)', async () => {
-            const res = await request(app)
-                .post('/computations/upload')
-                .set(auth())
-                .send({
-                    code: `module.exports = { config: { name: 'Evil', skills: [], requires: {} }, process(ctx) { require('fs'); return ctx; } };`,
-                    name: 'Evil',
-                });
-            expect(res.status).toBe(422);
-            expect(res.body.error).toBe('Verification failed');
-            expect(storage._saveCalls.length).toBe(0);
-        });
-
-        it('returns 422 and does not write to GCS when code fails verification (eval)', async () => {
-            const res = await request(app)
-                .post('/computations/upload')
-                .set(auth())
-                .send({
-                    code: `module.exports = { config: { name: 'Evil', skills: [], requires: {} }, process(ctx) { return eval('1+1'); } };`,
-                    name: 'Evil',
-                });
-            expect(res.status).toBe(422);
-            expect(res.body.error).toBe('Verification failed');
-            expect(storage._saveCalls.length).toBe(0);
-        });
-
-        it('returns 200 and writes to GCS when code passes verification', async () => {
-            // Use process: (ctx) => ... so extracted process source re-parses when wrapped in parens (method shorthand process(ctx){ } is invalid as a standalone expression).
-            const validCode = `module.exports = {
-                config: { name: 'SafeComp', typeOverride: 'global' },
-                process: (ctx) => ({ ok: true, date: ctx.date })
-            };`;
-            const res = await request(app)
-                .post('/computations/upload')
-                .set(auth())
-                .send({ code: validCode, name: 'SafeComp' });
-            expect(res.status).toBe(200);
+        it('returns 422 and does not write to GCS when code fails verification (process.env)', async () => {
+            const res = await request(app)
+                .post('/computations/upload')
+                .set(auth())
+                .send({
+                    code: `module.exports = { config: { name: 'Evil', skills: [], requires: {} }, process(ctx) { return process.env; } };`,
+                    name: 'Evil',
+                });
+            expect(res.status).toBe(422);
+            expect(res.body.error).toBe('Verification required');
+            expect(storage._saveCalls.length).toBe(0);
+        });
+
+        it('returns 422 and does not write to GCS when code fails verification (require)', async () => {
+            const res = await request(app)
+                .post('/computations/upload')
+                .set(auth())
+                .send({
+                    code: `module.exports = { config: { name: 'Evil', skills: [], requires: {} }, process(ctx) { require('fs'); return ctx; } };`,
+                    name: 'Evil',
+                });
+            expect(res.status).toBe(422);
+            expect(res.body.error).toBe('Verification required');
+            expect(storage._saveCalls.length).toBe(0);
+        });
+
+        it('returns 422 and does not write to GCS when code fails verification (eval)', async () => {
+            const res = await request(app)
+                .post('/computations/upload')
+                .set(auth())
+                .send({
+                    code: `module.exports = { config: { name: 'Evil', skills: [], requires: {} }, process(ctx) { return eval('1+1'); } };`,
+                    name: 'Evil',
+                });
+            expect(res.status).toBe(422);
+            expect(res.body.error).toBe('Verification required');
+            expect(storage._saveCalls.length).toBe(0);
+        });
+
+        it('returns 200 and writes to GCS when code passes verification', async () => {
+            // Use process: (ctx) => ... so extracted process source re-parses when wrapped in parens (method shorthand process(ctx){ } is invalid as a standalone expression).
+            const validCode = `module.exports = {
+                config: { name: 'SafeComp', typeOverride: 'global' },
+                process: (ctx) => ({ ok: true, date: ctx.date })
+            };`;
+            const crypto = require('crypto');
+            const codeHash = crypto.createHash('sha256').update(validCode).digest('hex');
+            db.seed('users/user-123/verification_status/safecomp', {
+                lastHash: codeHash,
+                lastVerificationId: 'verify-1',
+                lastVerifiedAt: new Date().toISOString(),
+                status: 'passed',
+                name: 'SafeComp',
+            });
+            const res = await request(app)
+                .post('/computations/upload')
+                .set(auth())
+                .send({ code: validCode, name: 'SafeComp' });
+            expect(res.status).toBe(200);
             expect(res.body.success).toBe(true);
             expect(res.body.hash).toBeDefined();
             expect(storage._saveCalls.length).toBe(1);

package/functions/api-v3/websocket/verification.js

@@ -6,6 +6,7 @@
 const { WebSocketServer } = require('ws');
 const { getAuth } = require('firebase-admin/auth');
 const { z } = require('zod');
+const crypto = require('crypto');
 const { Manifest } = require('../../computation-system-v3/framework/core/Manifest');
 const { runVerification } = require('../../computation-system-v3/verification/runVerification');
 const { getRedis } = require('../middleware/upstashRateLimit');
@@ -31,7 +32,10 @@ const StageSchema = z.object({
 const FinalSchema = z.object({
     passed: z.boolean(),
     errorCodes: z.array(z.string()).optional(),
-    errors: z.array(z.string()).optional()
+    errors: z.array(z.string()).optional(),
+    codeHash: z.string().optional(),
+    resultSummary: z.any().optional(),
+    resultPreview: z.any().optional()
 });
 
 async function resolveFirebaseUser(req) {
@@ -280,10 +284,14 @@ function attachVerificationWebSocketServer(server, dependencies, apiConfig = {})
                 onLog: (entry) => logEmitter(entry)
             });
 
+            const codeHash = crypto.createHash('sha256').update(payload.code).digest('hex');
             const finalPayload = {
                 passed: result.passed === true,
                 errorCodes: result.errorCodes || undefined,
-                errors: result.errors || undefined
+                errors: result.errors || undefined,
+                codeHash: result.passed === true ? codeHash : undefined,
+                resultSummary: result.passed === true ? (result.resultSummary || undefined) : undefined,
+                resultPreview: result.passed === true ? (result.resultPreview || undefined) : undefined
             };
             const finalParsed = FinalSchema.safeParse(finalPayload);
             if (finalParsed.success) {
@@ -294,9 +302,26 @@ function attachVerificationWebSocketServer(server, dependencies, apiConfig = {})
                 await auditRef.set({
                     finishedAt: new Date().toISOString(),
                     status: result.passed === true ? 'passed' : 'failed',
-                    errorCodes: result.errorCodes || null
+                    errorCodes: result.errorCodes || null,
+                    codeHash: result.passed === true ? codeHash : null,
+                    resultSummary: result.passed === true ? (result.resultSummary || null) : null
                 }, { merge: true });
             }
+            if (result.passed === true && services.db) {
+                const normalizedName = Manifest.normalize(payload.name || '');
+                if (normalizedName) {
+                    const statusRef = services.db.collection('users').doc(targetUserId)
+                        .collection('verification_status').doc(normalizedName);
+                    await statusRef.set({
+                        lastHash: codeHash,
+                        lastVerificationId: verificationId || null,
+                        lastVerifiedAt: new Date().toISOString(),
+                        status: 'passed',
+                        name: payload.name || null,
+                        resultSummary: result.resultSummary || null
+                    }, { merge: true });
+                }
+            }
 
             ws.close(1000, 'Verification complete');
         } catch (err) {

package/functions/computation-system-v3/verification/runVerification.js

@@ -28,6 +28,43 @@ const STAGE_DEPENDENCIES = 'dependencies';
 const STAGE_GCS_RULES = 'gcs_rules';
 const STAGE_DRY_RUN = 'dry_run';
 
+function summarizeResultValue(value) {
+    const type = value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value;
+    if (type === 'array') {
+        const arr = Array.isArray(value) ? value : [];
+        const firstNonNull = arr.find((v) => v !== null && v !== undefined);
+        const itemType = firstNonNull === null || firstNonNull === undefined
+            ? 'null'
+            : Array.isArray(firstNonNull) ? 'array' : typeof firstNonNull;
+        const summary = {
+            type: 'array',
+            length: arr.length,
+            itemType
+        };
+        if (itemType === 'object' && firstNonNull && typeof firstNonNull === 'object' && !Array.isArray(firstNonNull)) {
+            const keys = Object.keys(firstNonNull).slice(0, 50);
+            const fieldTypes = {};
+            for (const key of keys) {
+                const val = firstNonNull[key];
+                fieldTypes[key] = val === null ? 'null' : Array.isArray(val) ? 'array' : typeof val;
+            }
+            summary.keys = keys;
+            summary.fieldTypes = fieldTypes;
+        }
+        return summary;
+    }
+    if (type === 'object' && value && !Array.isArray(value)) {
+        const keys = Object.keys(value).slice(0, 50);
+        const fieldTypes = {};
+        for (const key of keys) {
+            const val = value[key];
+            fieldTypes[key] = val === null ? 'null' : Array.isArray(val) ? 'array' : typeof val;
+        }
+        return { type: 'object', keys, fieldTypes };
+    }
+    return { type };
+}
+
 /**
  * Get static computation names from built manifest (for dependency allow-list).
  */
@@ -242,7 +279,9 @@ async function runVerification(code, name, userId, options = {}) {
             const logOutput = Array.isArray(logBuffer)
                 ? logBuffer.filter((e) => e && typeof e === 'object' && 'ts' in e && 'message' in e).map((e) => ({ ts: e.ts, level: e.level || 'info', message: e.message }))
                 : [];
-            return { stages, passed: true, logOutput };
+            const resultPreview = result.result;
+            const resultSummary = summarizeResultValue(resultPreview);
+            return { stages, passed: true, logOutput, resultPreview, resultSummary };
         }
         let errMsg = 'Run did not complete successfully';
         if (result && result.error) {

package/functions/computation-system-v3/verification/sandbox-http.js

@@ -68,7 +68,9 @@ async function handleVerificationSandbox(req, res) {
             passed: result.passed === true,
             stages: result.stages || [],
             errors: result.errors || null,
-            errorCodes: result.errorCodes || null
+            errorCodes: result.errorCodes || null,
+            resultSummary: result.resultSummary || null,
+            resultPreview: result.resultPreview || null
         }));
     } catch (e) {
         console.error('[VerificationSandbox]', e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.1002",
+  "version": "1.0.1004",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [