@design.estate/wcctools 5.1.0

package/dist_ts_web/elements/wcctools.helpers.d.ts

@@ -0,0 +1,46 @@
+import type { TemplateResult } from 'lit';
+export type TTemplateFactory = () => TemplateResult | Promise<TemplateResult>;
+/** Find the nearest matching instance through light DOM and open shadow roots. */
+export declare const findElementInstance: <T extends HTMLElement>(containerArg: Element | ShadowRoot, elementClassArg: new (...args: any[]) => T) => T | null;
+export type TDemoDefinition = TTemplateFactory | TTemplateFactory[];
+/**
+ * How a catalog export is treated in an elements section:
+ * - `demo`: a custom element class with a usable static `demo`; listed and navigable
+ * - `no-demo`: a registered custom element without a usable demo; listed under "Without demo"
+ * - `ignored`: anything else (helpers, constants, types at runtime, abstract base classes)
+ */
+export type TCatalogEntryKind = 'demo' | 'no-demo' | 'ignored';
+/** The static surface wcctools reads from a catalog element class. */
+export interface ICatalogElementConstructor extends CustomElementConstructor {
+    demo?: unknown;
+    demoGroups?: unknown;
+}
+/** A demo is one template factory or a non-empty array of template factories. */
+export declare const isDemoDefinition: (demoArg: unknown) => demoArg is TDemoDefinition;
+/** True for classes that extend HTMLElement (registered or not). */
+export declare const isElementConstructor: (itemArg: unknown) => itemArg is ICatalogElementConstructor;
+/** Classify one export of an elements section. */
+export declare const classifyCatalogEntry: (itemArg: unknown) => TCatalogEntryKind;
+/** The tag name an element class is registered under, if any. */
+export declare const getElementTagName: (itemArg: unknown) => string | null;
+/** The demo groups an element declares, normalized to an array. */
+export declare const getElementDemoGroups: (itemArg: unknown) => string[];
+export type TPropertyType = 'String' | 'Number' | 'Boolean' | 'Object' | 'Enum' | 'Array';
+export interface IReactivePropertyDeclaration {
+    state?: boolean;
+    type?: unknown;
+}
+export declare const determinePropertyType: (propertyArg: IReactivePropertyDeclaration) => TPropertyType | null;
+export declare const resolveTemplateFactory: (factoryArg: TTemplateFactory) => Promise<TemplateResult>;
+/**
+ * Get the number of demos for an element
+ */
+export declare const getDemoCount: (demo: TDemoDefinition) => number;
+/**
+ * Get a specific demo by index (0-based internally, displayed as 1-based)
+ */
+export declare const getDemoAtIndex: (demo: TDemoDefinition, index: number) => TTemplateFactory | null;
+/**
+ * Check if an element has multiple demos
+ */
+export declare const hasMultipleDemos: (demo: TDemoDefinition) => boolean;

package/dist_ts_web/elements/wcctools.helpers.js

@@ -0,0 +1,106 @@
+/** Find the nearest matching instance through light DOM and open shadow roots. */
+export const findElementInstance = (containerArg, elementClassArg) => {
+    const pending = Array.from(containerArg.children);
+    for (let index = 0; index < pending.length; index++) {
+        const element = pending[index];
+        if (element instanceof elementClassArg)
+            return element;
+        pending.push(...element.children);
+        if (element.shadowRoot)
+            pending.push(...element.shadowRoot.children);
+    }
+    return null;
+};
+/** A demo is one template factory or a non-empty array of template factories. */
+export const isDemoDefinition = (demoArg) => {
+    if (typeof demoArg === 'function') {
+        return true;
+    }
+    return Array.isArray(demoArg)
+        && demoArg.length > 0
+        && demoArg.every((factoryArg) => typeof factoryArg === 'function');
+};
+/** True for classes that extend HTMLElement (registered or not). */
+export const isElementConstructor = (itemArg) => {
+    return typeof HTMLElement !== 'undefined'
+        && typeof itemArg === 'function'
+        && itemArg.prototype instanceof HTMLElement;
+};
+/** Classify one export of an elements section. */
+export const classifyCatalogEntry = (itemArg) => {
+    if (!isElementConstructor(itemArg)) {
+        return 'ignored';
+    }
+    if (isDemoDefinition(itemArg.demo)) {
+        return 'demo';
+    }
+    return customElements.getName(itemArg) ? 'no-demo' : 'ignored';
+};
+/** The tag name an element class is registered under, if any. */
+export const getElementTagName = (itemArg) => {
+    return isElementConstructor(itemArg) ? customElements.getName(itemArg) : null;
+};
+/** The demo groups an element declares, normalized to an array. */
+export const getElementDemoGroups = (itemArg) => {
+    if (!isElementConstructor(itemArg)) {
+        return [];
+    }
+    const groups = itemArg.demoGroups;
+    const list = Array.isArray(groups) ? groups : [groups];
+    return list.filter((groupArg) => typeof groupArg === 'string' && groupArg.length > 0);
+};
+const isEnumerationType = (typeArg) => {
+    if (!typeArg || typeof typeArg !== 'object' || Array.isArray(typeArg)) {
+        return false;
+    }
+    const values = Object.values(typeArg);
+    return values.length > 0 && values.every((valueArg) => typeof valueArg === 'string' || typeof valueArg === 'number');
+};
+export const determinePropertyType = (propertyArg) => {
+    if (!propertyArg || typeof propertyArg !== 'object' || propertyArg.state) {
+        return null;
+    }
+    switch (propertyArg.type) {
+        case String:
+            return 'String';
+        case Number:
+            return 'Number';
+        case Boolean:
+            return 'Boolean';
+        case Object:
+            return 'Object';
+        case Array:
+            return 'Array';
+        default:
+            return isEnumerationType(propertyArg.type) ? 'Enum' : null;
+    }
+};
+export const resolveTemplateFactory = async (factoryArg) => {
+    return await Promise.resolve(factoryArg());
+};
+/**
+ * Get the number of demos for an element
+ */
+export const getDemoCount = (demo) => {
+    if (Array.isArray(demo)) {
+        return demo.length;
+    }
+    return 1;
+};
+/**
+ * Get a specific demo by index (0-based internally, displayed as 1-based)
+ */
+export const getDemoAtIndex = (demo, index) => {
+    if (Array.isArray(demo)) {
+        return demo[index] ?? null;
+    }
+    // Single demo - only index 0 is valid
+    return index === 0 ? demo : null;
+};
+/**
+ * Check if an element has multiple demos
+ */
+export const hasMultipleDemos = (demo) => {
+    return Array.isArray(demo) && demo.length > 1;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_web/index.d.ts

@@ -0,0 +1,18 @@
+import type { IWccConfig } from './wcctools.interfaces.js';
+export { RecorderService, type IRecorderEvents, type IRecordingOptions, type TOutputFormat } from './services/recorder.service.js';
+export { WccRecordButton } from './elements/wcc-record-button.js';
+export { WccRecordingPanel } from './elements/wcc-recording-panel.js';
+export type { IWccConfig, IWccSection } from './wcctools.interfaces.js';
+/**
+ * Set up the WCC Tools dashboard:
+ * ```typescript
+ * setupWccTools({
+ *   sections: [
+ *     { name: 'Elements', type: 'elements', items: elements },
+ *     { name: 'Pages', type: 'pages', items: pages },
+ *   ]
+ * });
+ * ```
+ */
+declare const setupWccTools: (config: IWccConfig) => void;
+export { setupWccTools };

package/dist_ts_web/index.js

@@ -0,0 +1,30 @@
+import { WccDashboard } from './elements/wcc-dashboard.js';
+// Export recording components and service
+export { RecorderService } from './services/recorder.service.js';
+export { WccRecordButton } from './elements/wcc-record-button.js';
+export { WccRecordingPanel } from './elements/wcc-recording-panel.js';
+/**
+ * Set up the WCC Tools dashboard:
+ * ```typescript
+ * setupWccTools({
+ *   sections: [
+ *     { name: 'Elements', type: 'elements', items: elements },
+ *     { name: 'Pages', type: 'pages', items: pages },
+ *   ]
+ * });
+ * ```
+ */
+const setupWccTools = (config) => {
+    let hasRun = false;
+    const runWccToolsSetup = async () => {
+        if (document.readyState === 'complete' && !hasRun) {
+            hasRun = true;
+            const wccTools = new WccDashboard(config);
+            document.querySelector('body').append(wccTools);
+        }
+    };
+    document.addEventListener('readystatechange', runWccToolsSetup);
+    runWccToolsSetup();
+};
+export { setupWccTools };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c193ZWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRzNELDBDQUEwQztBQUMxQyxPQUFPLEVBQUUsZUFBZSxFQUFvRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ25JLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNsRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUt0RTs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxhQUFhLEdBQUcsQ0FBQyxNQUFrQixFQUFFLEVBQUU7SUFDM0MsSUFBSSxNQUFNLEdBQUcsS0FBSyxDQUFDO0lBQ25CLE1BQU0sZ0JBQWdCLEdBQUcsS0FBSyxJQUFJLEVBQUU7UUFDbEMsSUFBSSxRQUFRLENBQUMsVUFBVSxLQUFLLFVBQVUsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ2xELE1BQU0sR0FBRyxJQUFJLENBQUM7WUFDZCxNQUFNLFFBQVEsR0FBRyxJQUFJLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUMxQyxRQUFRLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUNsRCxDQUFDO0lBQ0gsQ0FBQyxDQUFDO0lBQ0YsUUFBUSxDQUFDLGdCQUFnQixDQUFDLGtCQUFrQixFQUFFLGdCQUFnQixDQUFDLENBQUM7SUFDaEUsZ0JBQWdCLEVBQUUsQ0FBQztBQUNyQixDQUFDLENBQUM7QUFFRixPQUFPLEVBQ0wsYUFBYSxFQUNkLENBQUMifQ==

package/dist_ts_web/pages/index.d.ts

@@ -0,0 +1 @@
+export declare const page1: any;

package/dist_ts_web/pages/index.js

@@ -0,0 +1,2 @@
+export const page1 = null;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c193ZWIvcGFnZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyJ9

package/dist_ts_web/services/recorder.service.d.ts

@@ -0,0 +1,55 @@
+/**
+ * RecorderService - Handles all MediaRecorder, audio monitoring, and video export logic.
+ * Recording always uses MediaRecorder → WebM (the reliable browser path).
+ * MP4 output is produced by converting WebM → MP4 via mediabunny at export time.
+ */
+export type TOutputFormat = 'webm' | 'mp4';
+export interface IRecorderEvents {
+    onDurationUpdate?: (duration: number) => void;
+    onRecordingComplete?: (blob: Blob) => void;
+    onAudioLevelUpdate?: (level: number) => void;
+    onError?: (error: Error) => void;
+    onStreamEnded?: () => void;
+}
+export interface IRecordingOptions {
+    mode: 'viewport' | 'screen';
+    audioDeviceId?: string;
+    viewportElement?: HTMLElement;
+    outputFormat?: TOutputFormat;
+}
+export declare class RecorderService {
+    private mediaRecorder;
+    private recordedChunks;
+    private durationInterval;
+    private _duration;
+    private _recordedBlob;
+    private _isRecording;
+    private _outputFormat;
+    private audioContext;
+    private audioAnalyser;
+    private audioMonitoringInterval;
+    private monitoringStream;
+    private currentStream;
+    private events;
+    constructor(events?: IRecorderEvents);
+    get isRecording(): boolean;
+    get duration(): number;
+    get recordedBlob(): Blob | null;
+    get outputFormat(): TOutputFormat;
+    setEvents(events: IRecorderEvents): void;
+    loadMicrophones(requestPermission?: boolean): Promise<MediaDeviceInfo[]>;
+    startAudioMonitoring(deviceId: string): Promise<void>;
+    stopAudioMonitoring(): void;
+    startRecording(options: IRecordingOptions): Promise<void>;
+    stopRecording(): void;
+    private handleRecordingComplete;
+    /**
+     * Converts a WebM blob to MP4 using mediabunny's Conversion API.
+     * Uses WebCodecs for hardware-accelerated H.264 encoding.
+     */
+    convertToMp4(webmBlob: Blob): Promise<Blob>;
+    exportTrimmedVideo(videoElement: HTMLVideoElement, trimStart: number, trimEnd: number): Promise<Blob>;
+    private recordTrimmedStream;
+    reset(): void;
+    dispose(): void;
+}

package/dist_ts_web/services/recorder.service.js

@@ -0,0 +1,353 @@
+/**
+ * RecorderService - Handles all MediaRecorder, audio monitoring, and video export logic.
+ * Recording always uses MediaRecorder → WebM (the reliable browser path).
+ * MP4 output is produced by converting WebM → MP4 via mediabunny at export time.
+ */
+export class RecorderService {
+    // Recording state
+    mediaRecorder = null;
+    recordedChunks = [];
+    durationInterval = null;
+    _duration = 0;
+    _recordedBlob = null;
+    _isRecording = false;
+    _outputFormat = 'webm';
+    // Audio monitoring state
+    audioContext = null;
+    audioAnalyser = null;
+    audioMonitoringInterval = null;
+    monitoringStream = null;
+    // Current recording stream
+    currentStream = null;
+    // Event callbacks
+    events = {};
+    constructor(events) {
+        if (events) {
+            this.events = events;
+        }
+    }
+    // Public getters
+    get isRecording() {
+        return this._isRecording;
+    }
+    get duration() {
+        return this._duration;
+    }
+    get recordedBlob() {
+        return this._recordedBlob;
+    }
+    get outputFormat() {
+        return this._outputFormat;
+    }
+    // Update event callbacks
+    setEvents(events) {
+        this.events = { ...this.events, ...events };
+    }
+    // ==================== Microphone Management ====================
+    async loadMicrophones(requestPermission = false) {
+        try {
+            if (requestPermission) {
+                // Request permission by getting a temporary stream
+                const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+                stream.getTracks().forEach(track => track.stop());
+            }
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.filter(d => d.kind === 'audioinput');
+        }
+        catch (error) {
+            console.error('Error loading microphones:', error);
+            return [];
+        }
+    }
+    async startAudioMonitoring(deviceId) {
+        this.stopAudioMonitoring();
+        if (!deviceId)
+            return;
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({
+                audio: { deviceId: { exact: deviceId } }
+            });
+            this.monitoringStream = stream;
+            this.audioContext = new AudioContext();
+            const source = this.audioContext.createMediaStreamSource(stream);
+            this.audioAnalyser = this.audioContext.createAnalyser();
+            this.audioAnalyser.fftSize = 256;
+            source.connect(this.audioAnalyser);
+            const dataArray = new Uint8Array(this.audioAnalyser.frequencyBinCount);
+            this.audioMonitoringInterval = window.setInterval(() => {
+                if (this.audioAnalyser) {
+                    this.audioAnalyser.getByteFrequencyData(dataArray);
+                    const average = dataArray.reduce((a, b) => a + b) / dataArray.length;
+                    const level = Math.min(100, (average / 128) * 100);
+                    this.events.onAudioLevelUpdate?.(level);
+                }
+            }, 50);
+        }
+        catch (error) {
+            console.error('Error starting audio monitoring:', error);
+            this.events.onAudioLevelUpdate?.(0);
+        }
+    }
+    stopAudioMonitoring() {
+        if (this.audioMonitoringInterval) {
+            clearInterval(this.audioMonitoringInterval);
+            this.audioMonitoringInterval = null;
+        }
+        if (this.audioContext) {
+            this.audioContext.close();
+            this.audioContext = null;
+        }
+        if (this.monitoringStream) {
+            this.monitoringStream.getTracks().forEach(track => track.stop());
+            this.monitoringStream = null;
+        }
+        this.audioAnalyser = null;
+    }
+    // ==================== Recording Control ====================
+    async startRecording(options) {
+        try {
+            this._outputFormat = options.outputFormat || 'webm';
+            // Stop audio monitoring before recording
+            this.stopAudioMonitoring();
+            // Get video stream based on mode
+            const displayMediaOptions = {
+                video: {
+                    displaySurface: options.mode === 'viewport' ? 'browser' : 'monitor',
+                    frameRate: { ideal: 60 },
+                },
+                audio: false
+            };
+            // Add preferCurrentTab hint for viewport mode
+            if (options.mode === 'viewport') {
+                displayMediaOptions.preferCurrentTab = true;
+            }
+            const videoStream = await navigator.mediaDevices.getDisplayMedia(displayMediaOptions);
+            // If viewport mode, try to crop to viewport element using Element Capture API
+            if (options.mode === 'viewport' && options.viewportElement) {
+                try {
+                    if ('CropTarget' in window) {
+                        const cropTarget = await window.CropTarget.fromElement(options.viewportElement);
+                        const [videoTrack] = videoStream.getVideoTracks();
+                        await videoTrack.cropTo(cropTarget);
+                    }
+                }
+                catch (e) {
+                    console.warn('Element Capture not supported, recording full tab:', e);
+                }
+            }
+            // Combine video with audio if enabled
+            let combinedStream = videoStream;
+            if (options.audioDeviceId) {
+                try {
+                    const audioStream = await navigator.mediaDevices.getUserMedia({
+                        audio: { deviceId: { exact: options.audioDeviceId } }
+                    });
+                    combinedStream = new MediaStream([
+                        ...videoStream.getVideoTracks(),
+                        ...audioStream.getAudioTracks()
+                    ]);
+                }
+                catch (audioError) {
+                    console.warn('Could not add audio:', audioError);
+                }
+            }
+            // Store stream for cleanup
+            this.currentStream = combinedStream;
+            // Handle stream ending (user clicks "Stop sharing")
+            videoStream.getVideoTracks()[0].onended = () => {
+                if (this._isRecording) {
+                    this.stopRecording();
+                    this.events.onStreamEnded?.();
+                }
+            };
+            // Always record as WebM — conversion to MP4 happens at export time
+            const mimeType = MediaRecorder.isTypeSupported('video/webm;codecs=vp9')
+                ? 'video/webm;codecs=vp9'
+                : 'video/webm';
+            this.mediaRecorder = new MediaRecorder(combinedStream, {
+                mimeType,
+                videoBitsPerSecond: 8_000_000, // 8 Mbps for smooth, high-quality capture
+            });
+            this.recordedChunks = [];
+            this.mediaRecorder.ondataavailable = (e) => {
+                if (e.data.size > 0) {
+                    this.recordedChunks.push(e.data);
+                }
+            };
+            this.mediaRecorder.onstop = () => this.handleRecordingComplete();
+            this.mediaRecorder.start(1000); // Capture in 1-second chunks
+            // Start duration timer
+            this._duration = 0;
+            this.durationInterval = window.setInterval(() => {
+                this._duration++;
+                this.events.onDurationUpdate?.(this._duration);
+            }, 1000);
+            this._isRecording = true;
+        }
+        catch (error) {
+            console.error('Error starting recording:', error);
+            this._isRecording = false;
+            this.events.onError?.(error);
+            throw error;
+        }
+    }
+    stopRecording() {
+        if (this.mediaRecorder && this.mediaRecorder.state !== 'inactive') {
+            this.mediaRecorder.stop();
+        }
+        if (this.durationInterval) {
+            clearInterval(this.durationInterval);
+            this.durationInterval = null;
+        }
+    }
+    async handleRecordingComplete() {
+        const blob = new Blob(this.recordedChunks, { type: 'video/webm' });
+        this._recordedBlob = blob;
+        // Stop all tracks
+        if (this.currentStream) {
+            this.currentStream.getTracks().forEach(track => track.stop());
+            this.currentStream = null;
+        }
+        this._isRecording = false;
+        this.events.onRecordingComplete?.(this._recordedBlob);
+    }
+    // ==================== Conversion & Export ====================
+    /**
+     * Converts a WebM blob to MP4 using mediabunny's Conversion API.
+     * Uses WebCodecs for hardware-accelerated H.264 encoding.
+     */
+    async convertToMp4(webmBlob) {
+        const { Input, Output, Conversion, BlobSource, BufferTarget, Mp4OutputFormat, WEBM, QUALITY_HIGH, } = await import('mediabunny');
+        const input = new Input({
+            source: new BlobSource(webmBlob),
+            formats: [WEBM],
+        });
+        const target = new BufferTarget();
+        const output = new Output({
+            format: new Mp4OutputFormat({ fastStart: 'in-memory' }),
+            target,
+        });
+        const conversion = await Conversion.init({
+            input,
+            output,
+            // Force transcoding from VP9 → H.264 and Opus → AAC
+            video: {
+                codec: 'avc',
+                bitrate: QUALITY_HIGH,
+                fit: 'contain',
+            },
+            audio: {
+                codec: 'aac',
+                bitrate: QUALITY_HIGH,
+            },
+        });
+        await conversion.execute();
+        const buffer = target.buffer;
+        if (!buffer || buffer.byteLength === 0) {
+            throw new Error('MP4 conversion produced empty output');
+        }
+        return new Blob([buffer], { type: 'video/mp4' });
+    }
+    async exportTrimmedVideo(videoElement, trimStart, trimEnd) {
+        return new Promise((resolve, reject) => {
+            // Create a canvas for capturing frames
+            const canvas = document.createElement('canvas');
+            canvas.width = videoElement.videoWidth || 1280;
+            canvas.height = videoElement.videoHeight || 720;
+            const ctx = canvas.getContext('2d');
+            if (!ctx) {
+                reject(new Error('Could not get canvas context'));
+                return;
+            }
+            // Create canvas stream for video
+            const canvasStream = canvas.captureStream(30);
+            // Try to capture audio from video element
+            let combinedStream;
+            try {
+                // Create audio context to capture video's audio
+                const audioCtx = new AudioContext();
+                const source = audioCtx.createMediaElementSource(videoElement);
+                const destination = audioCtx.createMediaStreamDestination();
+                source.connect(destination);
+                source.connect(audioCtx.destination); // Also play through speakers
+                // Combine video (from canvas) and audio (from video element)
+                combinedStream = new MediaStream([
+                    ...canvasStream.getVideoTracks(),
+                    ...destination.stream.getAudioTracks()
+                ]);
+                // Store audioCtx for cleanup
+                const cleanup = () => {
+                    audioCtx.close();
+                };
+                this.recordTrimmedStream(videoElement, canvas, ctx, combinedStream, trimStart, trimEnd, cleanup, resolve, reject);
+            }
+            catch (audioError) {
+                console.warn('Could not capture audio, recording video only:', audioError);
+                combinedStream = canvasStream;
+                this.recordTrimmedStream(videoElement, canvas, ctx, combinedStream, trimStart, trimEnd, () => { }, resolve, reject);
+            }
+        });
+    }
+    recordTrimmedStream(video, canvas, ctx, stream, trimStart, trimEnd, cleanup, resolve, reject) {
+        const mimeType = MediaRecorder.isTypeSupported('video/webm;codecs=vp9')
+            ? 'video/webm;codecs=vp9'
+            : 'video/webm';
+        const recorder = new MediaRecorder(stream, { mimeType });
+        const chunks = [];
+        recorder.ondataavailable = (e) => {
+            if (e.data.size > 0) {
+                chunks.push(e.data);
+            }
+        };
+        recorder.onstop = () => {
+            cleanup();
+            resolve(new Blob(chunks, { type: 'video/webm' }));
+        };
+        recorder.onerror = (e) => {
+            cleanup();
+            reject(new Error('Recording error: ' + e));
+        };
+        // Seek to trim start
+        video.currentTime = trimStart;
+        video.onseeked = () => {
+            // Start recording
+            recorder.start(100);
+            // Start playing
+            video.play();
+            // Draw frames to canvas
+            const drawFrame = () => {
+                if (video.currentTime >= trimEnd || video.paused || video.ended) {
+                    video.pause();
+                    video.onseeked = null;
+                    // Give a small delay before stopping to ensure last frame is captured
+                    setTimeout(() => {
+                        if (recorder.state === 'recording') {
+                            recorder.stop();
+                        }
+                    }, 100);
+                    return;
+                }
+                ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+                requestAnimationFrame(drawFrame);
+            };
+            drawFrame();
+        };
+    }
+    // ==================== Cleanup ====================
+    reset() {
+        this._recordedBlob = null;
+        this.recordedChunks = [];
+        this._duration = 0;
+        this._isRecording = false;
+    }
+    dispose() {
+        this.stopRecording();
+        this.stopAudioMonitoring();
+        this.reset();
+        if (this.currentStream) {
+            this.currentStream.getTracks().forEach(track => track.stop());
+            this.currentStream = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recorder.service.js","sourceRoot":"","sources":["../../ts_web/services/recorder.service.ts"],"names":[],"mappings":"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"}