Demo — Recording & Composition

import {
	createCommandRecorder,
	createPlaywrightVideoArtifact,
	createScreenRecorder
} from '@absolutejs/demo/recording';

// Wrap any CLI recorder — ffmpeg invocations, OBS command bridges, or
// platform-native recorders. start() spawns; stop() runs stopCommand
// (or SIGINTs the start process) and returns a recording artifact.
const obsRecorder = createCommandRecorder({
	startCommand: (run) => ['obs-cmd', 'recording', 'start'],
	stopCommand: (run) => ['obs-cmd', 'recording', 'stop'],
	outputPath: (run) => '.demo-video/' + run.id + '.mp4'
});

// Full-screen X11 recorder — captures REAL apps on a display, not just
// the Playwright browser. x11grab (+ optional PulseAudio) → mp4.
const screenRecorder = createScreenRecorder({
	outputPath: (run) => '.demo-video/' + run.id + '.mp4',
	display: ':0', // defaults to $DISPLAY or ':0' (WSLg)
	windowId: '0x1200004', // grab one X window (WSLg root is black)
	cropRect: { x: 0, y: 88, width: 1600, height: 812 }, // drop chrome
	framerate: 30,
	// PulseAudio: true → default source; or a sink monitor to record
	// playback (a live Meet/Discord call). Omit for video-only.
	audio: { device: 'rdp-sink.monitor' }
});

const runner = createDemoRunner({ recorder: screenRecorder });
// recorder.start() fires before step one; stop() runs after the last
// step (or on failure) and its artifact joins report.artifacts.

// Browser-only demos can skip a recorder entirely: pass recordVideoDir
// to createPlaywrightDemoSession and session.close() returns the video
// as a recording artifact — or wrap an existing file yourself:
const artifact = createPlaywrightVideoArtifact(
	'crm-demo-recording',
	'.demo-video/abc123.webm',
	{ source: 'playwright' }
);

import {
	createDeepgramAuraVoiceover,
	createElevenLabsVoiceover,
	createVoiceTTSVoiceover
} from '@absolutejs/demo/voiceover';

// Premium tier — the recommended default for client demos.
const premium = createElevenLabsVoiceover({
	apiKey: process.env.ELEVENLABS_API_KEY ?? '',
	outputDir: '.demo-voiceover',
	// Everything below is optional — these ARE the defaults:
	voiceId: '21m00Tcm4TlvDq8ikWAM', // Rachel (American)
	modelId: 'eleven_flash_v2_5',
	outputFormat: 'mp3_44100_128', // CBR → duration derivable
	voiceSettings: {
		stability: 0.42,
		similarityBoost: 0.78,
		style: 0.35,
		speed: 1,
		useSpeakerBoost: true
	},
	cacheDir: '.demo-voiceover/cache' // content-addressed render cache
});

// Faster and cheaper, reads more synthetic — fine for internal runs.
const fast = createDeepgramAuraVoiceover({
	apiKey: process.env.DEEPGRAM_API_KEY ?? '',
	outputDir: '.demo-voiceover',
	model: 'aura-asteria-en',
	sampleRateHz: 24000 // 8000 | 16000 | 24000 | 48000
});

// Or wrap any @absolutejs/voice TTSAdapter.
const adapter = createVoiceTTSVoiceover({
	tts: myTtsAdapter,
	outputDir: '.demo-voiceover'
});

// Narration steps drive whichever voiceover the runner holds:
narrate({
	text: 'Here is the live pipeline view.',
	emotion: 'confident', // 'neutral'|'confident'|'excited'|'calm'
	voice: 'pNInz6obpgDQGcFmaJgB' // per-line voice id override
});

import {
	applyPronunciationAliases,
	createElevenLabsVoiceover,
	DEFAULT_PRONUNCIATION_RULES,
	withPronunciationAliases,
	withRenderCache
} from '@absolutejs/demo/voiceover';

// Demo-vocabulary pronunciation fixes (onSpark, AbsoluteJS, PDL, …)
// applied before TTS, and identical lines cached so re-runs skip
// re-synthesis. Both wrappers are provider-agnostic.
const voiceover = withRenderCache(
	withPronunciationAliases(
		createElevenLabsVoiceover({
			apiKey: process.env.ELEVENLABS_API_KEY ?? '',
			outputDir: '.demo-voiceover'
		})
	),
	{ cacheDir: '.demo-voiceover/cache', salt: 'rachel:flash_v2_5' }
);

// Add product vocabulary on top of the shipped defaults.
withPronunciationAliases(voiceover, [
	...DEFAULT_PRONUNCIATION_RULES,
	{ match: 'K8s', replacement: 'kubernetes' }
]);
// Or rewrite text directly (word-boundary, case-insensitive):
applyPronunciationAliases('AbsoluteJS ships onSpark');
// → 'absolute jay ess ships on spark'

// Cache controls:
withRenderCache(voiceover, {
	cacheDir: '.demo-voiceover/cache',
	// Bump whenever voice/model/settings change so stale audio is
	// never replayed — the salt folds into the cache key.
	salt: 'rachel:flash_v2_5',
	// Return null to bypass the cache for a line (dynamic narration).
	keyFor: (input) => (input.metadata?.dynamic ? null : input.text)
});

import { composeDemoWithFFmpeg } from '@absolutejs/demo/composition';

// Mux the run recording and every voiceover artifact into one final
// video. Narration is offset against the recorded screen.
const finalVideo = await composeDemoWithFFmpeg(report, {
	outputPath: '.demo-artifacts/crm-demo.mp4'
});
// → { id: '<run>-composition', kind: 'composition', path, metadata }

// Every dial:
await composeDemoWithFFmpeg(report, {
	outputPath: '.demo-artifacts/crm-demo.mp4',
	audioMode: 'voiceover+recording', // keep live captured audio too
	voiceoverTiming: 'timeline', // place lines by run-clock offsets
	voiceoverGapMs: 250, // gap between lines in 'sequential' mode
	voiceoverOffsetsMs: { 'voiceover-3': 12400 }, // manual override wins
	videoCodec: 'libx264', // default for .mp4 output; 'copy' remuxes
	audioCodec: 'aac',
	extendVideo: true, // freeze the last frame until narration ends
	outputDurationMs: 95000,
	recordingPath: '.demo-video/override.webm', // bypass the artifact
	overwrite: true
});

// Or hold it behind the DemoComposer interface:
import { createFFmpegDemoComposer } from '@absolutejs/demo';
const composer = createFFmpegDemoComposer();
await composer.compose(report, { outputPath: 'final.mp4' });

import {
	createDemoManifest,
	createDemoSyncPlan,
	createDemoTimeline,
	getDemoArtifactOffsetMs,
	writeDemoManifest
} from '@absolutejs/demo';

// Timeline — run events + artifacts as offset-from-start entries.
const timeline = createDemoTimeline(report, { includeSteps: true });
// [{ id, type, at, offsetMs, label?, artifact? }, ...]
// type: 'run' | 'step' | 'artifact' | 'voiceover' | 'recording'
//     | 'screenshot' | 'composition'

// Where one artifact landed on the run clock.
const offsetMs = getDemoArtifactOffsetMs(report, 'voiceover-3');

// Manifest — a self-describing proof-of-run JSON document.
const manifest = await writeDemoManifest(
	report,
	'.demo-artifacts/crm-demo.manifest.json',
	{ environment: 'staging', gitSha: process.env.GIT_SHA }
);
// manifest.proof → { status, durationMs, artifactCount, eventCount,
//                    hasRecording, hasVoiceover }
// createDemoManifest(report, options) builds it without writing.

// Sync plan — author a narration/visual schedule ahead of a run. Items
// publish ReactiveEvents through @absolutejs/sync as they are added.
const plan = createDemoSyncPlan('crm-demo');
plan.addVoiceover({
	id: 'intro',
	text: 'Here is the live pipeline view.',
	artifact: voiceArtifact,
	durationMs: 5200
});
plan.addVisual({ id: 'callout', label: 'Spotlight', durationMs: 1800 });
plan.durationMs; // running end of the schedule
plan.events(); // the published ReactiveEvents