demowright 2.0.6 → 2.0.8

package/dist/config.d.mts

@@ -1,4 +1,4 @@
-import { t as QaHudOptions } from "./setup-D-Ut4FYK.mjs";
+import { t as QaHudOptions } from "./setup-Dwx0Dt54.mjs";
 import { PlaywrightTestConfig } from "@playwright/test";
 
 //#region src/config.d.ts

package/dist/config.mjs

@@ -1,5 +1,8 @@
-import { n as defaultOptions } from "./setup-B6UqVosV.mjs";
+import { n as defaultOptions } from "./setup-BwdzChHS.mjs";
 import { createRequire } from "node:module";
+import { execSync } from "node:child_process";
+import { mkdirSync, readdirSync } from "node:fs";
+import { join } from "node:path";
 //#region src/config.ts
 /**
 * Approach 3: Config helper (one line in playwright.config.ts).
@@ -30,7 +33,71 @@ function withDemowright(config, options) {
 	const flag = `--require ${registerPath}`;
 	const existing = process.env.NODE_OPTIONS || "";
 	if (!existing.includes(flag)) process.env.NODE_OPTIONS = existing ? `${existing} ${flag}` : flag;
+	if (opts.audio) {
+		const display = findLocalDisplay();
+		if (display) {
+			process.env.DISPLAY = display;
+			const use = config.use ??= {};
+			const launch = use.launchOptions ??= {};
+			if (launch.headless === void 0) launch.headless = false;
+		}
+		const pipePath = setupPulsePipeSink(opts.outputDir);
+		if (pipePath) process.env.__DEMOWRIGHT_PULSE_PIPE = pipePath;
+	}
 	return config;
 }
+/**
+* Create a PulseAudio pipe-sink in the main process.
+* Returns the FIFO path, or undefined if PulseAudio is unavailable.
+*/
+function setupPulsePipeSink(outputDir) {
+	try {
+		execSync("pactl info", { stdio: "pipe" });
+	} catch {
+		return;
+	}
+	const tmpDir = join(process.cwd(), outputDir, "tmp");
+	mkdirSync(tmpDir, { recursive: true });
+	const pipePath = join(tmpDir, `pulse-pipe-${Date.now()}.raw`);
+	try {
+		const modules = execSync("pactl list modules short", { encoding: "utf-8" });
+		for (const line of modules.split("\n")) if (line.includes("demowright_sink")) {
+			const modId = line.split("	")[0];
+			try {
+				execSync(`pactl unload-module ${modId}`, { stdio: "pipe" });
+			} catch {}
+		}
+	} catch {}
+	try {
+		execSync(`pactl load-module module-pipe-sink sink_name=demowright_sink file="${pipePath}" rate=44100 channels=2 format=s16le sink_properties=device.description="Demowright_Audio_Capture"`, { stdio: "pipe" });
+		execSync("pactl set-default-sink demowright_sink", { stdio: "pipe" });
+		return pipePath;
+	} catch {
+		return;
+	}
+}
+/**
+* Find a local X display (Xvfb) suitable for headed browser.
+* Prefers :99, then :98, then any local display.
+*/
+function findLocalDisplay() {
+	try {
+		const displays = readdirSync("/tmp/.X11-unix").filter((s) => s.startsWith("X")).map((s) => `:${s.slice(1)}`).sort((a, b) => {
+			const na = parseInt(a.slice(1)), nb = parseInt(b.slice(1));
+			if (na >= 98) return nb >= 98 ? na - nb : -1;
+			if (nb >= 98) return 1;
+			return na - nb;
+		});
+		for (const d of displays) try {
+			execSync(`DISPLAY=${d} xdpyinfo`, {
+				stdio: "pipe",
+				timeout: 2e3
+			});
+			return d;
+		} catch {}
+	} catch {}
+	const cur = process.env.DISPLAY;
+	if (cur && !cur.includes("localhost") && !cur.includes(":10")) return cur;
+}
 //#endregion
 export { withDemowright };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { installAutoAnnotate } from "./auto-annotate.mjs";
-import { a as AudioWriter, n as TtsProvider, r as applyHud, t as QaHudOptions } from "./setup-D-Ut4FYK.mjs";
+import { a as AudioWriter, n as TtsProvider, r as applyHud, t as QaHudOptions } from "./setup-Dwx0Dt54.mjs";
 import { annotate, caption, clickEl, hudWait, moveTo, moveToEl, narrate, subtitle, typeKeys } from "./helpers.mjs";
 import { OutroOptions, PaceFn, RenderOptions, TimelineEntry, TitleOptions, VideoScriptResult, buildFfmpegCommand, createVideoScript } from "./video-script.mjs";
 import { Page as Page$1, expect } from "@playwright/test";

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { r as AudioWriter, t as applyHud } from "./setup-B6UqVosV.mjs";
+import { r as AudioWriter, t as applyHud } from "./setup-BwdzChHS.mjs";
 import { i as getGlobalTtsProvider, s as init_hud_registry } from "./hud-registry-Wfd4b4Nu.mjs";
 import { buildFfmpegCommand, createVideoScript, t as init_video_script } from "./video-script.mjs";
 import { annotate, caption, clickEl, hudWait, moveTo, moveToEl, narrate, subtitle, typeKeys } from "./helpers.mjs";

package/dist/{setup-B6UqVosV.mjs → setup-BwdzChHS.mjs}

@@ -1,8 +1,8 @@
 import { r as __toCommonJS } from "./chunk-C0p4GxOx.mjs";
 import { a as getRenderJob, l as registerHudPage, n as getCurrentSpec, s as init_hud_registry, t as getAudioSegments, u as setGlobalOutputDir } from "./hud-registry-Wfd4b4Nu.mjs";
 import { n as video_script_exports, t as init_video_script } from "./video-script.mjs";
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { execSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/hud-overlay.ts
 /**
@@ -253,6 +253,7 @@ function audioCaptureMain() {
 		origConnect.call(gain, processor);
 		origConnect.call(processor, dest);
 		interceptors.set(dest, gain);
+		if (ctx.state === "suspended") ctx.resume?.();
 		return gain;
 	}
 	AudioNode.prototype.connect = function(dest, output, input) {
@@ -277,6 +278,7 @@ function audioCaptureMain() {
 			try {
 				const ctx = new AudioContext();
 				ctx.createMediaElementSource(this).connect(ctx.destination);
+				if (ctx.state === "suspended") ctx.resume();
 			} catch {}
 		}
 		return origPlay.call(this);
@@ -294,14 +296,24 @@ var AudioWriter = class {
 	chunks = [];
 	sampleRate = 44100;
 	channels = 2;
+	startMs = 0;
 	/**
 	* Called from the browser via page.exposeFunction.
 	* Receives interleaved stereo float32 samples.
 	*/
 	addChunk(samples, sampleRate) {
+		if (this.chunks.length === 0) this.startMs = Date.now();
 		this.sampleRate = sampleRate;
 		this.chunks.push(new Float32Array(samples));
 	}
+	/** Wall-clock time when first chunk arrived */
+	get captureStartMs() {
+		return this.startMs;
+	}
+	/** Sample rate of captured audio */
+	get rate() {
+		return this.sampleRate;
+	}
 	/** Total samples collected (interleaved, so / channels for per-channel) */
 	get totalSamples() {
 		return this.chunks.reduce((sum, c) => sum + c.length, 0);
@@ -339,6 +351,20 @@ var AudioWriter = class {
 		Buffer.from(int16.buffer).copy(buffer, 44);
 		writeFileSync(filePath, buffer);
 	}
+	/**
+	* Return all chunks concatenated as interleaved stereo float32.
+	*/
+	toFloat32() {
+		const total = this.totalSamples;
+		if (total === 0) return new Float32Array(0);
+		const out = new Float32Array(total);
+		let off = 0;
+		for (const chunk of this.chunks) {
+			out.set(chunk, off);
+			off += chunk.length;
+		}
+		return out;
+	}
 	/** Reset for reuse */
 	clear() {
 		this.chunks = [];
@@ -374,9 +400,11 @@ async function applyHud(context, options) {
 	const contextStartMs = Date.now();
 	await context.addInitScript(generateListenerScript());
 	let audioWriter;
+	let pulseCapture;
 	if (opts.audio) {
 		audioWriter = new AudioWriter();
 		await context.addInitScript(generateAudioCaptureScript());
+		pulseCapture = startPulseCapture(opts.outputDir);
 	}
 	const hudOpts = {
 		cursor: opts.cursor,
@@ -405,10 +433,13 @@ async function applyHud(context, options) {
 		const outDir = join(process.cwd(), opts.outputDir);
 		const tmpDir = join(outDir, "tmp");
 		mkdirSync(tmpDir, { recursive: true });
+		const gitignorePath = join(outDir, ".gitignore");
+		if (!existsSync(gitignorePath)) writeFileSync(gitignorePath, "*\n");
 		const audioPath = typeof opts.audio === "string" ? opts.audio : join(tmpDir, `demowright-audio-${Date.now()}.wav`);
 		const allPages = [...context.pages()];
 		context.on("page", (pg) => allPages.push(pg));
 		context.on("close", () => {
+			const pulseWavPath = pulseCapture?.stop();
 			for (const pg of allPages) {
 				const job = getRenderJob(pg);
 				if (job) {
@@ -418,19 +449,23 @@ async function applyHud(context, options) {
 			}
 			const segments = [];
 			for (const pg of allPages) segments.push(...getAudioSegments(pg));
+			const hasTts = segments.length > 0;
+			const hasBrowserAudio = audioWriter.totalSamples > 0;
+			const hasPulseAudio = pulseWavPath && existsSync(pulseWavPath);
+			if (!hasTts && !hasBrowserAudio && !hasPulseAudio) return;
 			let audioOffsetMs = 0;
-			if (segments.length > 0) {
-				const firstSegMs = segments[0].timestampMs;
+			if (hasTts || hasPulseAudio) {
+				const firstSegMs = hasTts ? segments[0].timestampMs : contextStartMs;
 				audioOffsetMs = firstSegMs - contextStartMs;
-				buildAndSaveAudioTrack(segments, audioPath, firstSegMs);
-			} else if (audioWriter.totalSamples > 0) audioWriter.save(audioPath);
-			else return;
+				buildAndSaveAudioTrack(segments, audioPath, firstSegMs, hasBrowserAudio ? audioWriter : void 0, contextStartMs, hasPulseAudio ? pulseWavPath : void 0);
+			} else audioWriter.save(audioPath);
+			if (hasPulseAudio) console.log(`[demowright] Pulse audio captured: ${pulseWavPath}`);
 			const mp4Path = join(outDir, `${getCurrentSpec() ?? pageNames[0] ?? `demowright-${Date.now()}`}.mp4`);
 			const trimSec = (audioOffsetMs / 1e3).toFixed(3);
 			let muxed = false;
 			for (const videoPath of videoPaths) try {
 				if (!existsSync(videoPath)) continue;
-				execSync(`ffmpeg -y -ss ${trimSec} -i "${videoPath}" -i "${audioPath}" -c:v libx264 -preset fast -c:a aac -shortest "${mp4Path}"`, { stdio: "pipe" });
+				execSync(`ffmpeg -y -ss ${trimSec} -i "${videoPath}" -i "${audioPath}" -c:v libx264 -preset fast -crf 28 -c:a aac -b:a 64k -shortest "${mp4Path}"`, { stdio: "pipe" });
 				muxed = true;
 				try {
 					unlinkSync(audioPath);
@@ -439,7 +474,7 @@ async function applyHud(context, options) {
 			} catch {}
 			if (!muxed) {
 				console.log(`[demowright] Audio saved: ${audioPath}`);
-				console.log(`[demowright] Mux: ffmpeg -y -ss ${trimSec} -i <video.webm> -i "${audioPath}" -c:v libx264 -preset fast -c:a aac -shortest "${mp4Path}"`);
+				console.log(`[demowright] Mux: ffmpeg -y -ss ${trimSec} -i <video.webm> -i "${audioPath}" -c:v libx264 -preset fast -crf 28 -c:a aac -b:a 64k -shortest "${mp4Path}"`);
 			}
 		});
 	}
@@ -548,11 +583,12 @@ async function setupAudioCapture(page, writer) {
 * wall-clock timestamps. Silence fills gaps between segments.
 * This eliminates drift caused by page.evaluate overhead.
 */
-function buildAndSaveAudioTrack(segments, outputPath, contextStartMs) {
-	if (segments.length === 0) return;
-	const firstBuf = segments[0].wavBuf;
-	if (firstBuf.indexOf("data") + 8 < 8) return;
-	const sampleRate = firstBuf.readUInt32LE(24);
+function buildAndSaveAudioTrack(segments, outputPath, contextStartMs, browserAudio, contextCreationMs, pulseWavPath) {
+	if (segments.length === 0 && !browserAudio && !pulseWavPath) return;
+	const firstBuf = segments[0]?.wavBuf;
+	const dataOffset0 = firstBuf ? firstBuf.indexOf("data") + 8 : -1;
+	if (segments.length > 0 && dataOffset0 < 8) return;
+	const sampleRate = firstBuf ? firstBuf.readUInt32LE(24) : browserAudio?.rate ?? 44100;
 	const channels = 2;
 	const baseMs = contextStartMs;
 	let totalMs = 0;
@@ -565,6 +601,22 @@ function buildAndSaveAudioTrack(segments, outputPath, contextStartMs) {
 		const endMs = seg.timestampMs - baseMs + segDur;
 		if (endMs > totalMs) totalMs = endMs;
 	}
+	if (browserAudio && browserAudio.totalSamples > 0) {
+		const browserStartMs = browserAudio.captureStartMs;
+		const browserDurMs = browserAudio.duration * 1e3;
+		const browserEndMs = browserStartMs - baseMs + browserDurMs;
+		if (browserEndMs > totalMs) totalMs = browserEndMs;
+	}
+	if (pulseWavPath && existsSync(pulseWavPath)) try {
+		const pBuf = readFileSync(pulseWavPath);
+		const pDoff = pBuf.indexOf("data");
+		if (pDoff >= 0) {
+			const pSr = pBuf.readUInt32LE(24);
+			const pCh = pBuf.readUInt16LE(22);
+			const pDurMs = pBuf.readUInt32LE(pDoff + 4) / 2 / pCh / pSr * 1e3;
+			if (pDurMs > totalMs) totalMs = pDurMs;
+		}
+	} catch {}
 	const totalSamples = Math.ceil(totalMs / 1e3 * sampleRate * channels);
 	const trackBuffer = new Float32Array(totalSamples);
 	for (const seg of segments) {
@@ -588,6 +640,58 @@ function buildAndSaveAudioTrack(segments, outputPath, contextStartMs) {
 		const offsetSamples = Math.floor(offsetMs / 1e3 * sampleRate) * channels;
 		for (let i = 0; i < stereo.length && offsetSamples + i < trackBuffer.length; i++) trackBuffer[offsetSamples + i] += stereo[i];
 	}
+	if (browserAudio && browserAudio.totalSamples > 0) {
+		const browserPcm = browserAudio.toFloat32();
+		const browserOffsetMs = browserAudio.captureStartMs - baseMs;
+		const browserOffsetSamples = Math.max(0, Math.floor(browserOffsetMs / 1e3 * sampleRate) * channels);
+		if (browserAudio.rate === sampleRate) for (let i = 0; i < browserPcm.length && browserOffsetSamples + i < trackBuffer.length; i++) trackBuffer[browserOffsetSamples + i] += browserPcm[i];
+		else {
+			const ratio = browserAudio.rate / sampleRate;
+			const outLen = Math.floor(browserPcm.length / ratio);
+			for (let i = 0; i < outLen && browserOffsetSamples + i < trackBuffer.length; i++) {
+				const srcIdx = i * ratio;
+				const lo = Math.floor(srcIdx);
+				const hi = Math.min(lo + 1, browserPcm.length - 1);
+				const frac = srcIdx - lo;
+				trackBuffer[browserOffsetSamples + i] += browserPcm[lo] * (1 - frac) + browserPcm[hi] * frac;
+			}
+		}
+	}
+	if (pulseWavPath && existsSync(pulseWavPath)) try {
+		const pulseBuf = readFileSync(pulseWavPath);
+		const pDoff = pulseBuf.indexOf("data");
+		if (pDoff >= 0) {
+			const pSr = pulseBuf.readUInt32LE(24);
+			const pCh = pulseBuf.readUInt16LE(22);
+			const pBps = pulseBuf.readUInt16LE(34);
+			const pcmData = pulseBuf.subarray(pDoff + 8);
+			const bytesPerSample = pBps / 8;
+			const sampleCount = Math.floor(pcmData.length / bytesPerSample);
+			const float32 = new Float32Array(sampleCount);
+			for (let i = 0; i < sampleCount; i++) if (pBps === 16) float32[i] = pcmData.readInt16LE(i * 2) / 32768;
+			else if (pBps === 32) float32[i] = pcmData.readFloatLE(i * 4);
+			const stereo = pCh === 1 ? (() => {
+				const s = new Float32Array(sampleCount * 2);
+				for (let i = 0; i < sampleCount; i++) {
+					s[i * 2] = float32[i];
+					s[i * 2 + 1] = float32[i];
+				}
+				return s;
+			})() : float32;
+			if (pSr === sampleRate) for (let i = 0; i < stereo.length && i < trackBuffer.length; i++) trackBuffer[i] += stereo[i];
+			else {
+				const ratio = pSr / sampleRate;
+				const outLen = Math.min(Math.floor(stereo.length / ratio), trackBuffer.length);
+				for (let i = 0; i < outLen; i++) {
+					const srcIdx = i * ratio;
+					const lo = Math.floor(srcIdx);
+					const hi = Math.min(lo + 1, stereo.length - 1);
+					const frac = srcIdx - lo;
+					trackBuffer[i] += stereo[lo] * (1 - frac) + stereo[hi] * frac;
+				}
+			}
+		}
+	} catch {}
 	const int16 = new Int16Array(trackBuffer.length);
 	for (let i = 0; i < trackBuffer.length; i++) {
 		const s = Math.max(-1, Math.min(1, trackBuffer[i]));
@@ -639,7 +743,7 @@ function finalizeRenderJob(job, videoPaths) {
 			`-i "${job.wavPath}"`,
 			chapterArgs,
 			vf,
-			`-c:v libx264 -preset fast`,
+			`-c:v libx264 -preset fast -crf 28`,
 			`-c:a aac`,
 			`-shortest`,
 			`"${job.mp4Path}"`
@@ -664,5 +768,114 @@ function finalizeRenderJob(job, videoPaths) {
 		}
 	}
 }
+function startPulseCapture(outputDir) {
+	const g = globalThis;
+	if (g.__qaHudPulseCapture) return g.__qaHudPulseCapture;
+	const preCreatedPipe = process.env.__DEMOWRIGHT_PULSE_PIPE;
+	if (!preCreatedPipe) return startPulseCaptureDirectly(outputDir);
+	const tmpDir = join(process.cwd(), outputDir, "tmp");
+	mkdirSync(tmpDir, { recursive: true });
+	const wavPath = join(tmpDir, `pulse-capture-${Date.now()}.wav`);
+	const pipePath = preCreatedPipe;
+	const MAX_BYTES = 44100 * 2 * 2 * 300;
+	let ringBuffer = Buffer.alloc(0);
+	let totalBytesReceived = 0;
+	let readerProc;
+	try {
+		readerProc = spawn("cat", [pipePath], { stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		] });
+		readerProc.stdout.on("data", (chunk) => {
+			totalBytesReceived += chunk.length;
+			ringBuffer = Buffer.concat([ringBuffer, chunk]);
+			if (ringBuffer.length > MAX_BYTES) {
+				const excess = ringBuffer.length - MAX_BYTES;
+				const alignedExcess = excess - excess % 4;
+				ringBuffer = ringBuffer.subarray(alignedExcess);
+			}
+		});
+		console.log(`[demowright] Pulse pipe-sink capture started: pipe=${pipePath}, PID=${readerProc.pid}`);
+	} catch (e) {
+		console.log(`[demowright] Pulse pipe reader failed: ${e.message}`);
+		return;
+	}
+	const handle = { stop() {
+		g.__qaHudPulseCapture = void 0;
+		try {
+			readerProc?.kill("SIGTERM");
+		} catch {}
+		try {
+			const modules = execSync("pactl list modules short", { encoding: "utf-8" });
+			for (const line of modules.split("\n")) if (line.includes("demowright_sink")) {
+				const modId = line.split("	")[0];
+				try {
+					execSync(`pactl unload-module ${modId}`, { stdio: "pipe" });
+				} catch {}
+			}
+		} catch {}
+		const raw = ringBuffer;
+		const durSec = raw.length / 44100 / 4;
+		console.log(`[demowright] Pulse audio: ${(totalBytesReceived / 1024 / 1024).toFixed(1)}MB received, ${raw.length} bytes kept, ${durSec.toFixed(1)}s`);
+		try {
+			unlinkSync(pipePath);
+		} catch {}
+		if (raw.length === 0) return void 0;
+		const maxWavData = 4294967259;
+		const pcmData = raw.length > maxWavData ? raw.subarray(raw.length - maxWavData) : raw;
+		const hdr = Buffer.alloc(44);
+		hdr.write("RIFF", 0);
+		hdr.writeUInt32LE(36 + pcmData.length, 4);
+		hdr.write("WAVE", 8);
+		hdr.write("fmt ", 12);
+		hdr.writeUInt32LE(16, 16);
+		hdr.writeUInt16LE(1, 20);
+		hdr.writeUInt16LE(2, 22);
+		hdr.writeUInt32LE(44100, 24);
+		hdr.writeUInt32LE(44100 * 2 * 2, 28);
+		hdr.writeUInt16LE(4, 32);
+		hdr.writeUInt16LE(16, 34);
+		hdr.write("data", 36);
+		hdr.writeUInt32LE(pcmData.length, 40);
+		writeFileSync(wavPath, Buffer.concat([hdr, pcmData]));
+		return wavPath;
+	} };
+	g.__qaHudPulseCapture = handle;
+	return handle;
+}
+/**
+* Fallback: create pipe-sink directly (for programmatic applyHud without config.ts).
+*/
+function startPulseCaptureDirectly(outputDir) {
+	try {
+		execSync("pactl info", { stdio: "pipe" });
+	} catch {
+		return;
+	}
+	const tmpDir = join(process.cwd(), outputDir, "tmp");
+	mkdirSync(tmpDir, { recursive: true });
+	const pipePath = join(tmpDir, `pulse-pipe-${Date.now()}.raw`);
+	try {
+		const modules = execSync("pactl list modules short", { encoding: "utf-8" });
+		for (const line of modules.split("\n")) if (line.includes("demowright_sink")) {
+			const modId = line.split("	")[0];
+			try {
+				execSync(`pactl unload-module ${modId}`, { stdio: "pipe" });
+			} catch {}
+		}
+	} catch {}
+	try {
+		execSync(`pactl load-module module-pipe-sink sink_name=demowright_sink file="${pipePath}" rate=44100 channels=2 format=s16le sink_properties=device.description="Demowright_Audio_Capture"`, {
+			stdio: "pipe",
+			encoding: "utf-8"
+		}).trim();
+		execSync("pactl set-default-sink demowright_sink", { stdio: "pipe" });
+	} catch {
+		return;
+	}
+	process.env.__DEMOWRIGHT_PULSE_PIPE = pipePath;
+	return startPulseCapture(outputDir);
+}
 //#endregion
 export { defaultOptions as n, AudioWriter as r, applyHud as t };

package/dist/{setup-D-Ut4FYK.d.mts → setup-Dwx0Dt54.d.mts}

@@ -20,11 +20,16 @@ declare class AudioWriter {
   private chunks;
   private sampleRate;
   private channels;
+  private startMs;
   /**
    * Called from the browser via page.exposeFunction.
    * Receives interleaved stereo float32 samples.
    */
   addChunk(samples: number[], sampleRate: number): void;
+  /** Wall-clock time when first chunk arrived */
+  get captureStartMs(): number;
+  /** Sample rate of captured audio */
+  get rate(): number;
   /** Total samples collected (interleaved, so / channels for per-channel) */
   get totalSamples(): number;
   get duration(): number;
@@ -32,6 +37,10 @@ declare class AudioWriter {
    * Write collected audio to a WAV file.
    */
   save(filePath: string): void;
+  /**
+   * Return all chunks concatenated as interleaved stereo float32.
+   */
+  toFloat32(): Float32Array;
   /** Reset for reuse */
   clear(): void;
 }

package/dist/setup.d.mts

@@ -1,2 +1,2 @@
-import { i as defaultOptions, n as TtsProvider, r as applyHud, t as QaHudOptions } from "./setup-D-Ut4FYK.mjs";
+import { i as defaultOptions, n as TtsProvider, r as applyHud, t as QaHudOptions } from "./setup-Dwx0Dt54.mjs";
 export { QaHudOptions, TtsProvider, applyHud, defaultOptions };

package/dist/setup.mjs

@@ -1,2 +1,2 @@
-import { n as defaultOptions, t as applyHud } from "./setup-B6UqVosV.mjs";
+import { n as defaultOptions, t as applyHud } from "./setup-BwdzChHS.mjs";
 export { applyHud, defaultOptions };

package/dist/video-script.mjs

@@ -1,6 +1,6 @@
 import { n as __exportAll, t as __esmMin } from "./chunk-C0p4GxOx.mjs";
 import { c as isHudActive, d as storeAudioSegment, f as storeRenderJob, i as getGlobalTtsProvider, o as getTtsProvider, r as getGlobalOutputDir, s as init_hud_registry } from "./hud-registry-Wfd4b4Nu.mjs";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/video-script.ts
 /**
@@ -388,6 +388,8 @@ var init_video_script = __esmMin((() => {
 			const baseName = opts?.baseName ?? `demowright-video-${Date.now()}`;
 			mkdirSync(outputDir, { recursive: true });
 			mkdirSync(tmpDir, { recursive: true });
+			const gitignorePath = join(outputDir, ".gitignore");
+			if (!existsSync(gitignorePath)) writeFileSync(gitignorePath, "*\n");
 			const wavPath = join(tmpDir, `${baseName}.wav`);
 			const srtPath = join(tmpDir, `${baseName}.srt`);
 			const chaptersPath = join(tmpDir, `${baseName}-chapters.txt`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "demowright",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Playwright video production plugin — cursor overlay, keystroke badges, TTS narration, and narration-driven video scripts for test recordings",
   "license": "MIT",
   "repository": {