@goscribe/server 1.6.0 → 1.7.0

package/dist/src/services/content/podcast.service.js

@@ -0,0 +1,653 @@
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { v4 as uuidv4 } from 'uuid';
+import { BaseService } from '../base.service.js';
+import { ArtifactType } from '../../lib/constants.js';
+import { ai } from '../../lib/ai/index.js';
+import { generateSignedUrl, deleteFromSupabase } from '../../lib/storage.js';
+import PusherService from '../../lib/pusher.js';
+import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+export const speakerSchema = z.object({
+    id: z.string(),
+    role: z.enum(['host', 'guest', 'expert']),
+    name: z.string().optional(),
+});
+export const podcastInputSchema = z.object({
+    title: z.string(),
+    description: z.string().optional(),
+    userPrompt: z.string(),
+    speakers: z
+        .array(speakerSchema)
+        .min(1)
+        .default([{ id: 'pNInz6obpgDQGcFmaJgB', role: 'host' }]),
+    speed: z.number().min(0.25).max(4.0).default(1.0),
+    generateIntro: z.boolean().default(true),
+    generateOutro: z.boolean().default(true),
+    segmentByTopics: z.boolean().default(true),
+});
+export const podcastMetadataSchema = z.object({
+    title: z.string(),
+    description: z.string().optional(),
+    totalDuration: z.number(),
+    speakers: z.array(speakerSchema),
+    summary: z.object({
+        executiveSummary: z.string(),
+        learningObjectives: z.array(z.string()),
+        keyConcepts: z.array(z.string()),
+        followUpActions: z.array(z.string()),
+        targetAudience: z.string(),
+        prerequisites: z.array(z.string()),
+        tags: z.array(z.string()),
+    }),
+    generatedAt: z.string(),
+});
+export class PodcastService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async listEpisodes(userId, workspaceId) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: workspaceId, ownerId: userId },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const artifacts = await this.db.artifact.findMany({
+            where: { workspaceId, type: ArtifactType.PODCAST_EPISODE },
+            include: {
+                versions: { orderBy: { version: 'desc' }, take: 1 },
+                podcastSegments: { orderBy: { order: 'asc' } },
+            },
+            orderBy: { updatedAt: 'desc' },
+        });
+        this.logger.debug(`Found ${artifacts.length} podcast artifacts`);
+        artifacts.forEach((artifact, i) => {
+            this.logger.debug(`  Podcast ${i + 1}: "${artifact.title}" - ${artifact.podcastSegments.length} segments`);
+        });
+        const episodesWithUrls = await Promise.all(artifacts.map(async (artifact) => {
+            const latestVersion = artifact.versions[0];
+            let objectUrl = null;
+            if (artifact.imageObjectKey) {
+                objectUrl = await generateSignedUrl(artifact.imageObjectKey, 24);
+            }
+            const segmentsWithUrls = await Promise.all(artifact.podcastSegments.map(async (segment) => {
+                if (segment.objectKey) {
+                    try {
+                        const signedUrl = await generateSignedUrl(segment.objectKey, 24);
+                        return {
+                            id: segment.id,
+                            title: segment.title,
+                            audioUrl: signedUrl,
+                            objectKey: segment.objectKey,
+                            startTime: segment.startTime,
+                            duration: segment.duration,
+                            order: segment.order,
+                        };
+                    }
+                    catch (error) {
+                        this.logger.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+                        return {
+                            id: segment.id,
+                            title: segment.title,
+                            audioUrl: null,
+                            objectKey: segment.objectKey,
+                            startTime: segment.startTime,
+                            duration: segment.duration,
+                            order: segment.order,
+                        };
+                    }
+                }
+                return {
+                    id: segment.id,
+                    title: segment.title,
+                    audioUrl: null,
+                    objectKey: segment.objectKey,
+                    startTime: segment.startTime,
+                    duration: segment.duration,
+                    order: segment.order,
+                };
+            }));
+            let metadata = null;
+            if (latestVersion) {
+                try {
+                    this.logger.debug(JSON.stringify(latestVersion.data));
+                    metadata = podcastMetadataSchema.parse(latestVersion.data);
+                }
+                catch (error) {
+                    this.logger.error('Failed to parse podcast metadata:', error);
+                }
+            }
+            return {
+                id: artifact.id,
+                title: metadata?.title || artifact.title || 'Untitled Episode',
+                description: metadata?.description || artifact.description || null,
+                metadata,
+                imageUrl: objectUrl,
+                segments: segmentsWithUrls,
+                createdAt: artifact.createdAt,
+                updatedAt: artifact.updatedAt,
+                workspaceId: artifact.workspaceId,
+                generating: artifact.generating,
+                generatingMetadata: artifact.generatingMetadata,
+                type: artifact.type,
+                createdById: artifact.createdById,
+                isArchived: artifact.isArchived,
+            };
+        }));
+        return episodesWithUrls;
+    }
+    async getEpisode(userId, episodeId) {
+        const episode = await this.db.artifact.findFirst({
+            where: {
+                id: episodeId,
+                type: ArtifactType.PODCAST_EPISODE,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include: {
+                versions: { orderBy: { version: 'desc' }, take: 1 },
+                podcastSegments: { orderBy: { order: 'asc' } },
+            },
+        });
+        this.logger.debug(JSON.stringify(episode));
+        if (!episode)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const latestVersion = episode.versions[0];
+        if (!latestVersion)
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
+        this.logger.debug(JSON.stringify(latestVersion));
+        try {
+            podcastMetadataSchema.parse(latestVersion.data);
+        }
+        catch (error) {
+            this.logger.error('Failed to parse podcast metadata:', error);
+        }
+        const metadata = podcastMetadataSchema.parse(latestVersion.data);
+        const imageUrl = episode.imageObjectKey
+            ? await generateSignedUrl(episode.imageObjectKey, 24)
+            : null;
+        const segmentsWithUrls = await Promise.all(episode.podcastSegments.map(async (segment) => {
+            if (segment.objectKey) {
+                try {
+                    const signedUrl = await generateSignedUrl(segment.objectKey, 24);
+                    return {
+                        id: segment.id,
+                        title: segment.title,
+                        content: segment.content,
+                        audioUrl: signedUrl,
+                        objectKey: segment.objectKey,
+                        startTime: segment.startTime,
+                        duration: segment.duration,
+                        keyPoints: segment.keyPoints,
+                        order: segment.order,
+                    };
+                }
+                catch (error) {
+                    this.logger.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+                    return {
+                        id: segment.id,
+                        title: segment.title,
+                        content: segment.content,
+                        audioUrl: null,
+                        objectKey: segment.objectKey,
+                        startTime: segment.startTime,
+                        duration: segment.duration,
+                        keyPoints: segment.keyPoints,
+                        order: segment.order,
+                    };
+                }
+            }
+            return {
+                id: segment.id,
+                title: segment.title,
+                content: segment.content,
+                audioUrl: null,
+                objectKey: segment.objectKey,
+                startTime: segment.startTime,
+                duration: segment.duration,
+                keyPoints: segment.keyPoints,
+                order: segment.order,
+            };
+        }));
+        return {
+            id: episode.id,
+            title: metadata.title,
+            description: metadata.description,
+            metadata,
+            imageUrl,
+            segments: segmentsWithUrls,
+            content: latestVersion.content,
+            createdAt: episode.createdAt,
+            updatedAt: episode.updatedAt,
+        };
+    }
+    async generateEpisode(userId, input) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: userId },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_generation_start', {
+            title: input.podcastData.title,
+        });
+        const BEGIN_PODCAST_GENERATION_MESSAGE = 'Structuring podcast contents...';
+        const newArtifact = await this.db.artifact.create({
+            data: {
+                title: '----',
+                type: ArtifactType.PODCAST_EPISODE,
+                generating: true,
+                generatingMetadata: { message: BEGIN_PODCAST_GENERATION_MESSAGE },
+                workspace: { connect: { id: input.workspaceId } },
+            },
+        });
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+            message: BEGIN_PODCAST_GENERATION_MESSAGE,
+        });
+        try {
+            const structureResult = await ai.backend.generatePodcastStructure(input.workspaceId, userId, input.podcastData.title, input.podcastData.description || '', input.podcastData.userPrompt, input.podcastData.speakers);
+            if (!structureResult.success || !structureResult.structure) {
+                throw new TRPCError({
+                    code: 'INTERNAL_SERVER_ERROR',
+                    message: 'Failed to generate podcast structure',
+                });
+            }
+            const structure = structureResult.structure;
+            await this.db.artifact.update({
+                where: { id: newArtifact.id },
+                data: { title: structure.episodeTitle },
+            });
+            const segments = [];
+            const failedSegments = [];
+            let totalDuration = 0;
+            let fullTranscript = '';
+            await this.db.artifact.update({
+                where: { id: newArtifact.id },
+                data: { generatingMetadata: { message: `Generating podcast image...` } },
+            });
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+                message: `Generating podcast image...`,
+            });
+            const podcastImage = await ai.backend.generatePodcastImage(input.workspaceId, userId, structure.segments.map((segment) => segment.content).join('\n\n'));
+            await this.db.artifact.update({
+                where: { id: newArtifact.id },
+                data: { imageObjectKey: podcastImage },
+            });
+            for (let i = 0; i < structure.segments.length; i++) {
+                const segment = structure.segments[i];
+                try {
+                    await this.db.artifact.update({
+                        where: { id: newArtifact.id },
+                        data: {
+                            generatingMetadata: {
+                                message: `Generating audio for "${segment.title}" (${i + 1} of ${structure.segments.length})...`,
+                            },
+                        },
+                    });
+                    await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+                        message: `Generating audio for segment ${i + 1} of ${structure.segments.length}...`,
+                    });
+                    const audioResult = await ai.backend.generatePodcastAudioFromText(input.workspaceId, userId, newArtifact.id, i, segment.content, input.podcastData.speakers, segment.voiceId);
+                    if (!audioResult.success) {
+                        throw new Error('Failed to generate audio for segment');
+                    }
+                    segments.push({
+                        id: uuidv4(),
+                        title: segment.title,
+                        content: segment.content,
+                        objectKey: audioResult.objectKey,
+                        startTime: totalDuration,
+                        duration: audioResult.duration,
+                        keyPoints: segment.keyPoints || [],
+                        order: segment.order || i + 1,
+                    });
+                    totalDuration += audioResult.duration;
+                    fullTranscript += `\n\n## ${segment.title}\n\n${segment.content}`;
+                }
+                catch (audioError) {
+                    const errorMessage = audioError instanceof Error ? audioError.message : 'Unknown error';
+                    this.logger.error(`❌ Error generating audio for segment ${i + 1}:`, {
+                        title: segment.title,
+                        error: errorMessage,
+                        stack: audioError instanceof Error ? audioError.stack : undefined,
+                    });
+                    failedSegments.push({
+                        index: i + 1,
+                        title: segment.title || `Segment ${i + 1}`,
+                        error: errorMessage,
+                    });
+                    await PusherService.emitTaskComplete(input.workspaceId, 'podcast_segment_error', {
+                        segmentIndex: i + 1,
+                        segmentTitle: segment.title || `Segment ${i + 1}`,
+                        error: errorMessage,
+                        successfulSegments: segments.length,
+                        failedSegments: failedSegments.length,
+                    });
+                }
+            }
+            if (segments.length === 0) {
+                this.logger.error('No segments were successfully generated');
+                await PusherService.emitError(input.workspaceId, `Failed to generate any segments. ${failedSegments.length} segment(s) failed.`, 'podcast');
+                await notifyArtifactFailed(this.db, {
+                    userId,
+                    workspaceId: input.workspaceId,
+                    artifactType: ArtifactType.PODCAST_EPISODE,
+                    artifactId: newArtifact.id,
+                    title: input.podcastData.title,
+                    message: `Failed to generate any audio segments. All ${failedSegments.length} attempts failed.`,
+                }).catch(() => { });
+                await this.db.artifact.delete({ where: { id: newArtifact.id } });
+                throw new TRPCError({
+                    code: 'INTERNAL_SERVER_ERROR',
+                    message: `Failed to generate any audio segments. All ${failedSegments.length} attempts failed.`,
+                });
+            }
+            await this.db.artifact.update({
+                where: { id: newArtifact.id },
+                data: { generatingMetadata: { message: `Preparing podcast summary...` } },
+            });
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+                message: `Preparing podcast summary...`,
+            });
+            const summaryPrompt = `Create a comprehensive podcast episode summary including:
+        - Executive summary
+        - Learning objectives
+        - Key concepts covered
+        - Recommended follow-up actions
+        - Target audience
+        - Prerequisites (if any)
+
+        Format as JSON:
+        {
+          "executiveSummary": "Brief overview of the episode",
+          "learningObjectives": ["objective1", "objective2"],
+          "keyConcepts": ["concept1", "concept2"],
+          "followUpActions": ["action1", "action2"],
+          "targetAudience": "Description of target audience",
+          "prerequisites": ["prerequisite1", "prerequisite2"],
+          "tags": ["tag1", "tag2", "tag3"]
+        }
+
+        Podcast Title: ${structure.episodeTitle}
+        Segments: ${JSON.stringify(segments.map((s) => ({ title: s.title, keyPoints: s.keyPoints })))}`;
+            const summaryResponse = await ai.llm.complete([{ role: 'user', content: summaryPrompt }]);
+            const summaryContent = summaryResponse.choices[0].message.content || '';
+            let episodeSummary;
+            try {
+                const jsonMatch = summaryContent.match(/\{[\s\S]*\}/);
+                if (!jsonMatch) {
+                    throw new Error('No JSON found in summary response');
+                }
+                episodeSummary = JSON.parse(jsonMatch[0]);
+            }
+            catch (parseError) {
+                this.logger.error('Failed to parse summary response:', summaryContent);
+                await PusherService.emitTaskComplete(input.workspaceId, 'podcast_summary_error', {
+                    error: 'Failed to parse summary response',
+                });
+                episodeSummary = {
+                    executiveSummary: 'AI-generated podcast episode',
+                    learningObjectives: [],
+                    keyConcepts: [],
+                    followUpActions: [],
+                    targetAudience: 'General audience',
+                    prerequisites: [],
+                    tags: [],
+                };
+            }
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+                message: `Podcast summary generated.`,
+            });
+            const episodeTitle = structure.episodeTitle || input.podcastData.title;
+            await this.db.artifact.update({
+                where: { id: newArtifact.id },
+                data: {
+                    workspaceId: input.workspaceId,
+                    type: ArtifactType.PODCAST_EPISODE,
+                    title: episodeTitle,
+                    description: input.podcastData.description,
+                    createdById: userId,
+                },
+            });
+            await this.db.podcastSegment.createMany({
+                data: segments.map((segment) => ({
+                    artifactId: newArtifact.id,
+                    title: segment.title,
+                    content: segment.content,
+                    startTime: segment.startTime,
+                    duration: segment.duration,
+                    order: segment.order,
+                    objectKey: segment.objectKey,
+                    keyPoints: segment.keyPoints,
+                    meta: {
+                        speed: input.podcastData.speed,
+                        speakers: input.podcastData.speakers,
+                    },
+                })),
+            });
+            const metadata = {
+                title: episodeTitle,
+                description: input.podcastData.description,
+                totalDuration,
+                summary: episodeSummary,
+                speakers: input.podcastData.speakers,
+                generatedAt: new Date().toISOString(),
+            };
+            await this.db.artifactVersion.create({
+                data: {
+                    artifactId: newArtifact.id,
+                    version: 1,
+                    content: fullTranscript.trim(),
+                    data: metadata,
+                    createdById: userId,
+                },
+            });
+            await this.db.artifact.update({
+                where: { id: newArtifact.id },
+                data: { generating: false },
+            });
+            await PusherService.emitPodcastComplete(input.workspaceId, newArtifact);
+            await notifyArtifactReady(this.db, {
+                userId,
+                workspaceId: input.workspaceId,
+                artifactId: newArtifact.id,
+                artifactType: ArtifactType.PODCAST_EPISODE,
+                title: metadata.title,
+            }).catch(() => { });
+            return {
+                id: newArtifact.id,
+                title: metadata.title,
+                description: metadata.description,
+                metadata,
+                content: fullTranscript.trim(),
+            };
+        }
+        catch (error) {
+            this.logger.error('Error generating podcast episode:', error);
+            await notifyArtifactFailed(this.db, {
+                userId,
+                workspaceId: input.workspaceId,
+                artifactType: ArtifactType.PODCAST_EPISODE,
+                artifactId: newArtifact.id,
+                title: input.podcastData.title,
+                message: error instanceof Error ? error.message : 'Podcast generation failed.',
+            }).catch(() => { });
+            await this.db.artifact.delete({ where: { id: newArtifact.id } });
+            await PusherService.emitError(input.workspaceId, `Failed to generate podcast episode: ${error instanceof Error ? error.message : 'Unknown error'}`, 'podcast');
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to generate podcast episode: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    async deleteSegment(segmentId) {
+        return this.db.podcastSegment.delete({ where: { id: segmentId } });
+    }
+    async getEpisodeSchema(userId, episodeId) {
+        const episode = await this.db.artifact.findFirst({
+            where: {
+                id: episodeId,
+                type: ArtifactType.PODCAST_EPISODE,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include: {
+                versions: { orderBy: { version: 'desc' }, take: 1 },
+                podcastSegments: { orderBy: { order: 'asc' } },
+            },
+        });
+        if (!episode)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const latestVersion = episode.versions[0];
+        if (!latestVersion)
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
+        const metadata = podcastMetadataSchema.parse(latestVersion.data);
+        return {
+            segments: episode.podcastSegments.map((s) => ({
+                id: s.id,
+                title: s.title,
+                startTime: s.startTime,
+                duration: s.duration,
+                keyPoints: s.keyPoints,
+                order: s.order,
+            })),
+            summary: metadata.summary,
+            metadata: {
+                title: metadata.title,
+                description: metadata.description,
+                totalDuration: metadata.totalDuration,
+                speakers: metadata.speakers,
+            },
+        };
+    }
+    async updateEpisode(userId, input) {
+        const episode = await this.db.artifact.findFirst({
+            where: {
+                id: input.episodeId,
+                type: ArtifactType.PODCAST_EPISODE,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include: {
+                versions: { orderBy: { version: 'desc' }, take: 1 },
+            },
+        });
+        if (!episode)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const latestVersion = episode.versions[0];
+        if (!latestVersion)
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
+        const metadata = podcastMetadataSchema.parse(latestVersion.data);
+        if (input.title)
+            metadata.title = input.title;
+        if (input.description)
+            metadata.description = input.description;
+        const nextVersion = (latestVersion.version || 0) + 1;
+        await this.db.artifactVersion.create({
+            data: {
+                artifactId: input.episodeId,
+                version: nextVersion,
+                content: latestVersion.content,
+                data: metadata,
+                createdById: userId,
+            },
+        });
+        return this.db.artifact.update({
+            where: { id: input.episodeId },
+            data: {
+                title: input.title ?? episode.title,
+                description: input.description ?? episode.description,
+                updatedAt: new Date(),
+            },
+        });
+    }
+    async deleteEpisode(userId, episodeId) {
+        const episode = await this.db.artifact.findFirst({
+            where: {
+                id: episodeId,
+                type: ArtifactType.PODCAST_EPISODE,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include: {
+                versions: { orderBy: { version: 'desc' }, take: 1 },
+            },
+        });
+        if (!episode)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        try {
+            await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_deletion_start', {
+                episodeId,
+                episodeTitle: episode.title || 'Untitled Episode',
+            });
+            const segments = await this.db.podcastSegment.findMany({
+                where: { artifactId: episodeId },
+            });
+            for (const segment of segments) {
+                if (segment.objectKey) {
+                    try {
+                        await deleteFromSupabase(segment.objectKey);
+                    }
+                    catch (error) {
+                        this.logger.error(`Failed to delete audio file ${segment.objectKey}:`, error);
+                    }
+                }
+            }
+            await this.db.podcastSegment.deleteMany({ where: { artifactId: episodeId } });
+            await this.db.artifactVersion.deleteMany({ where: { artifactId: episodeId } });
+            await this.db.artifact.delete({ where: { id: episodeId } });
+            await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_deletion_complete', {
+                episodeId,
+                episodeTitle: episode.title || 'Untitled Episode',
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Error deleting episode:', error);
+            await PusherService.emitError(episode.workspaceId, `Failed to delete episode: ${error instanceof Error ? error.message : 'Unknown error'}`, 'podcast');
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'Failed to delete episode',
+            });
+        }
+    }
+    async getSegment(userId, segmentId) {
+        const segment = await this.db.podcastSegment.findFirst({
+            where: {
+                id: segmentId,
+                artifact: { workspace: workspaceAccessWhere(userId) },
+            },
+            include: { artifact: true },
+        });
+        if (!segment)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        let audioUrl = null;
+        if (segment.objectKey) {
+            try {
+                audioUrl = await generateSignedUrl(segment.objectKey, 24);
+            }
+            catch (error) {
+                this.logger.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+            }
+        }
+        return {
+            id: segment.id,
+            title: segment.title,
+            content: segment.content,
+            startTime: segment.startTime,
+            duration: segment.duration,
+            order: segment.order,
+            keyPoints: segment.keyPoints,
+            audioUrl,
+            objectKey: segment.objectKey,
+            meta: segment.meta,
+            createdAt: segment.createdAt,
+            updatedAt: segment.updatedAt,
+        };
+    }
+    getAvailableVoices() {
+        return [
+            { id: 'alloy', name: 'Alloy', description: 'Neutral, balanced voice' },
+            { id: 'echo', name: 'Echo', description: 'Clear, professional voice' },
+            { id: 'fable', name: 'Fable', description: 'Warm, storytelling voice' },
+            { id: 'onyx', name: 'Onyx', description: 'Deep, authoritative voice' },
+            { id: 'nova', name: 'Nova', description: 'Friendly, conversational voice' },
+            { id: 'shimmer', name: 'Shimmer', description: 'Bright, energetic voice' },
+        ];
+    }
+}

package/dist/src/services/content/worksheet-content.service.d.ts

@@ -0,0 +1,37 @@
+import type { PrismaClient, WorksheetQuestion } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+export type WorksheetQuestionWithProgress = Omit<WorksheetQuestion, 'meta'> & {
+    meta: Record<string, unknown>;
+};
+type ProgressLike = {
+    worksheetQuestionId: string;
+    modified: boolean;
+    userAnswer: string | null;
+    completedAt: Date | null;
+    meta?: unknown;
+};
+export declare function mergeWorksheetQuestionProgress(questions: WorksheetQuestion[], progressRows: ProgressLike[]): WorksheetQuestionWithProgress[];
+export declare function parseWorksheetGenerationContent(content: string): {
+    problems: Record<string, unknown>[];
+    title?: string;
+    description?: string;
+    estimatedTime?: string;
+};
+export declare function parseQuestionMeta(meta: unknown): Record<string, unknown>;
+/**
+ * Class wrapper around the pure worksheet-content helpers so consumers can
+ * depend on a service the same way they depend on other domain services.
+ * The standalone function exports remain part of the public surface.
+ */
+export declare class WorksheetContentService extends BaseService {
+    constructor(db: PrismaClient);
+    mergeProgress(questions: WorksheetQuestion[], progress: ProgressLike[]): WorksheetQuestionWithProgress[];
+    parseGenerationContent(content: string): {
+        problems: Record<string, unknown>[];
+        title?: string;
+        description?: string;
+        estimatedTime?: string;
+    };
+    parseQuestionMeta(meta: unknown): Record<string, unknown>;
+}
+export {};