@tricoteuses/transcription-videos 1.7.0 → 1.7.2

package/dist/core/identification/engine.d.ts

@@ -47,6 +47,9 @@ export declare class SpeakerIdentificationEngine {
      *  each cascade run; windowed claims take precedence over the flat mapping
      *  for segments inside their [startMs, endMs] window. */
     private windowedMapping;
+    /** Consecutive runCascade() invocations whose fetchContext returned null
+     *  (reset on success). Drives the throttled visibility warning. */
+    private contextFailCount;
     /** Source key → canonical key for applied merges (cumulative, first-seen wins). */
     private mergeRemap;
     private rosterById;

package/dist/core/identification/engine.js

@@ -28,6 +28,9 @@ export class SpeakerIdentificationEngine {
      *  each cascade run; windowed claims take precedence over the flat mapping
      *  for segments inside their [startMs, endMs] window. */
     windowedMapping = new Map();
+    /** Consecutive runCascade() invocations whose fetchContext returned null
+     *  (reset on success). Drives the throttled visibility warning. */
+    contextFailCount = 0;
     /** Source key → canonical key for applied merges (cumulative, first-seen wins). */
     mergeRemap = new Map();
     rosterById = new Map();
@@ -239,9 +242,15 @@ export class SpeakerIdentificationEngine {
         }
         const ctx = await this.args.fetchContext();
         if (!ctx) {
-            this.log('No identification context fetched → skipping run');
+            // Visible outside debug: a persistently missing context silently
+            // disables identification (e.g. NVS unavailable on the remote source).
+            this.contextFailCount += 1;
+            if (this.contextFailCount % 10 === 1) {
+                console.warn('[SpeakerIdentificationEngine]', `No identification context fetched (×${this.contextFailCount}) → skipping run`);
+            }
             return;
         }
+        this.contextFailCount = 0;
         // Roster lookup for meta enrichment (url, role, …)
         this.rosterById = new Map((ctx.roster ?? []).map((r) => [r.id, r]));
         // Windowed claims are stateless per run: rebuilt from scratch so a key
@@ -268,7 +277,9 @@ export class SpeakerIdentificationEngine {
                 decided = normalizeDecideResult(raw);
             }
             catch (err) {
-                this.log(`Backend ${backend.name} error:`, err?.message ?? err);
+                // Visible outside debug: a repeatedly failing backend (bad API key,
+                // invalid model id, unreachable endpoint) silently disables the layer.
+                console.warn('[SpeakerIdentificationEngine]', `Backend ${backend.name} error:`, err?.message ?? err);
                 continue;
             }
             for (const [key, claims] of Object.entries(decided.splits ?? {})) {

package/dist/core/media/resolve.d.ts

@@ -13,6 +13,8 @@ export type ResolveDeps = {
     exists: (p: string) => Promise<boolean>;
     getStreamUrl: (url: string) => Promise<string>;
 };
+/** Watch-page URL yt-dlp can introspect for metadata (YouTube watch / live / youtu.be). */
+export declare function isYouTubeWatchUrl(url: string | null | undefined): boolean;
 /** Local path usable as-is by ffmpeg. */
 export declare function resolvedTarget(input: ResolvedInput): string;
 /** Kill yt-dlp resolution after this long: an extractor hang must not hang the job. */

package/dist/core/media/resolve.js

@@ -1,6 +1,26 @@
 import fs from 'node:fs';
 import { execa } from 'execa';
 const MEDIA_EXT_RE = /\.(m3u8|mpd|mp3|m4a|aac|wav|flac|ogg|opus|oga|mp4|m4v|mkv|webm|mov|ts|m2ts|avi|flv|wmv)(\?.*)?$/i;
+/** Watch-page URL yt-dlp can introspect for metadata (YouTube watch / live / youtu.be). */
+export function isYouTubeWatchUrl(url) {
+    if (!url)
+        return false;
+    try {
+        const parsed = new URL(url.trim());
+        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
+            return false;
+        const host = parsed.hostname.replace(/^www\./, '');
+        if (host === 'youtu.be')
+            return true;
+        if (host === 'youtube.com' || host === 'm.youtube.com' || host === 'music.youtube.com') {
+            return parsed.pathname === '/watch' || parsed.pathname.startsWith('/live/');
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 /** Local path usable as-is by ffmpeg. */
 export function resolvedTarget(input) {
     return input.kind === 'file' ? input.path : input.url;

package/dist/parliament/live/transcription.d.ts

@@ -9,6 +9,26 @@ export type PushOpts = {
     preflightProbe?: boolean;
 };
 export declare function nvsStartTimeToEpochMs(startTimeNvs: string): number | null;
+/** PostgreSQL INT4 max: the API stores paragraph timecodes as INT4. */
+export declare const INT32_MAX_MS = 2147483647;
+/**
+ * Video-relative timecode offset (ms) for a session attempt anchored on the
+ * HLS PROGRAM-DATE-TIME read position. Hierarchy: NVS broadcast start, then
+ * video broadcast start (YouTube), else null — the absolute epoch must never
+ * leak into a timecode (INT4 overflow API-side).
+ */
+export declare function computePdtTimecodeOffsetMs(args: {
+    pdtAnchorMs: number;
+    startTimeNvs?: string | null;
+    broadcastStartMs?: number | null;
+}): number | null;
+export declare function toParagrapheApi(evt: any): {
+    start_ms: number;
+    end_ms: number;
+    speaker: string | null;
+    text: string;
+    confidence: number | null;
+} | null;
 /**
  * DebatDirect adapter over the generic runStreamSession loop: holds every
  * parliament-specific concern (status polling, timecode offsets AN/SN, rolling

package/dist/parliament/live/transcription.js

@@ -55,7 +55,31 @@ function computeTimecodeOffsetMs(startTimeNvs, sessionStartedAtMs) {
     // Offset is “current video timecode” at session start; never negative.
     return Math.max(0, Math.round(offset));
 }
-function toParagrapheApi(evt) {
+/** PostgreSQL INT4 max: the API stores paragraph timecodes as INT4. */
+export const INT32_MAX_MS = 2_147_483_647;
+/**
+ * Video-relative timecode offset (ms) for a session attempt anchored on the
+ * HLS PROGRAM-DATE-TIME read position. Hierarchy: NVS broadcast start, then
+ * video broadcast start (YouTube), else null — the absolute epoch must never
+ * leak into a timecode (INT4 overflow API-side).
+ */
+export function computePdtTimecodeOffsetMs(args) {
+    const { pdtAnchorMs, startTimeNvs, broadcastStartMs } = args;
+    if (!Number.isFinite(pdtAnchorMs))
+        return null;
+    const startEpochMs = nvsStartTimeToEpochMs(startTimeNvs ?? '');
+    if (startEpochMs != null)
+        return Math.max(0, Math.round(pdtAnchorMs - startEpochMs));
+    if (typeof broadcastStartMs === 'number' &&
+        Number.isFinite(broadcastStartMs) &&
+        broadcastStartMs > 0) {
+        return Math.max(0, Math.round(pdtAnchorMs - broadcastStartMs));
+    }
+    return null;
+}
+/** Logged once per process: an over-INT4 offset is a steady state (24/7 streams), not a one-off. */
+let int4OffsetWarningShown = false;
+export function toParagrapheApi(evt) {
     if (evt?.type !== 'utterance')
         return null;
     let start_ms = Number(evt.start);
@@ -69,11 +93,26 @@ function toParagrapheApi(evt) {
         : '';
     console.log(`[toParagrapheApi] start=${start_ms} end=${end_ms} offsetMs=${offsetMs}${absLabel}`);
     if (offsetMs != null && Number.isFinite(offsetMs)) {
-        start_ms += offsetMs;
-        end_ms += offsetMs;
+        if (offsetMs > INT32_MAX_MS) {
+            // Video position beyond what an INT4 timecode can hold (>24.8 days:
+            // epoch leak or permanent stream). Storing it would overflow INT4
+            // API-side; ignore the offset and keep relative timecodes flowing.
+            if (!int4OffsetWarningShown) {
+                int4OffsetWarningShown = true;
+                console.error(`[toParagrapheApi] timecodeOffsetMs=${offsetMs} exceeds INT4 (>24.8 days video position), offset ignored — timecodes stay relative to the read position`);
+            }
+        }
+        else {
+            start_ms += offsetMs;
+            end_ms += offsetMs;
+        }
     }
     if (!text || !Number.isFinite(start_ms) || !Number.isFinite(end_ms))
         return null;
+    if (start_ms > INT32_MAX_MS || end_ms > INT32_MAX_MS) {
+        console.error(`[toParagrapheApi] start_ms=${start_ms} end_ms=${end_ms} exceed INT4, paragraph dropped`);
+        return null;
+    }
     return {
         start_ms,
         end_ms,
@@ -207,17 +246,21 @@ export async function runForeverPush(args) {
             sessionStartMeta: ({ startedAtMs, restartOffsetSec, pdtAnchorMs }) => {
                 const startSecOffset = startSec ? startSec * 1000 : 0;
                 if (pdtAnchorMs != null) {
-                    // Absolute anchor measured on the actual read position (live edge
-                    // in stream mode, VOD start in media mode): video-relative when the
-                    // NVS epoch is known, absolute wall-clock otherwise. The empirical
-                    // AN/SN latency constants do not apply on this path.
-                    const startEpochMs = nvsStartTimeToEpochMs(startTimeNvs ?? '');
-                    const relative = startEpochMs != null ? pdtAnchorMs - startEpochMs : pdtAnchorMs;
-                    return {
-                        startTimeNvs,
-                        timecodeOffsetMs: Math.max(0, Math.round(relative)) + startSecOffset,
-                        timecodeSource: 'pdt',
-                    };
+                    // Video-relative offset when a broadcast start is known (NVS epoch
+                    // for AN/SN, video metadata epoch for YouTube); null otherwise.
+                    // The empirical AN/SN latency constants do not apply on this path.
+                    const offsetMs = computePdtTimecodeOffsetMs({ pdtAnchorMs, startTimeNvs, broadcastStartMs });
+                    return offsetMs != null
+                        ? {
+                            startTimeNvs,
+                            timecodeOffsetMs: offsetMs + startSecOffset,
+                            timecodeSource: 'pdt',
+                        }
+                        : {
+                            startTimeNvs,
+                            timecodeOffsetMs: null,
+                            timecodeSource: 'pdt-no-start',
+                        };
                 }
                 const activeTs = activeStartTime(restartOffsetSec);
                 const nvsOffset = computeTimecodeOffsetMs(activeTs ? String(activeTs) : (startTimeNvs ?? null), startedAtMs);

package/dist/scripts/transcribe_live.js

@@ -5,7 +5,7 @@ import { resolveSourceUrl, getStreamProvider, withSharedTranscribeOptions } from
 import { transcribeReplay } from './replay.js';
 import { fetchDebatDirect, resolveReunionSessionTitle } from '../parliament/live/api.js';
 import { nvsStartTimeToEpochMs, runForeverPush } from '../parliament/live/transcription.js';
-import { resolveVideoMetadata } from '../core/media/resolve.js';
+import { resolveVideoMetadata, isYouTubeWatchUrl } from '../core/media/resolve.js';
 import { fetchText } from '../core/http.js';
 import { PARLIAMENT_HEADERS } from '../parliament/constants.js';
 async function transcribeLive(opts) {
@@ -73,6 +73,25 @@ async function transcribeLive(opts) {
                 console.info(`[live] livePlayerNvs starttime: ${startTimeNvs}`);
             }
         }
+        // No NVS (e.g. GVT YouTube directs): anchor the video timebase on the
+        // YouTube broadcast start so live timecodes stay video-relative. Without
+        // it the PDT anchor would leak an absolute epoch into the timecode
+        // (INT4 overflow API-side). Best-effort: null on failure (degraded mode).
+        if (!livePlayerNvsUrl && isYouTubeWatchUrl(direct.m3u8Url)) {
+            try {
+                const metadata = await resolveVideoMetadata(direct.m3u8Url);
+                urlBroadcastStartMs = metadata?.timestampMs ?? null;
+                if (urlBroadcastStartMs != null) {
+                    console.info(`[live] youtube broadcast start: ${new Date(urlBroadcastStartMs).toISOString()}`);
+                }
+                else {
+                    console.warn('[live] youtube broadcast start unavailable, degraded timecode mode');
+                }
+            }
+            catch (err) {
+                console.warn(`[live] youtube broadcast start lookup failed: ${err?.message ?? err}`);
+            }
+        }
     }
     const resolveUrl = async () => {
         if (opts.url)

package/dist/src/config/env.js

@@ -1,49 +1,23 @@
 import 'dotenv/config';
 import { z } from 'zod';
 const EnvSchema = z.object({
-    TRANSCRIPTION_PROVIDER: z.enum(['assemblyai', 'deepgram', 'mistral']).default('deepgram'),
-    ASSEMBLYAI_API_KEY: z.string().optional(),
+    TRANSCRIPTION_PROVIDER: z.enum(['assemblyai', 'deepgram']).default('deepgram'),
+    ASSEMBLYAI_API_KEY: z.string().min(1, 'ASSEMBLYAI_API_KEY is required'),
     ASSEMBLYAI_BASE_URL: z.string().url().optional(),
     DEFAULT_LANGUAGE: z.string().default('fr'),
     DEFAULT_DIARIZATION: z.string().default('true'),
     DEEPGRAM_API_KEY: z.string().optional(),
     DEEPGRAM_MODEL: z.string().default('nova-3'),
-    DEEPGRAM_DIARIZE_MODEL: z.enum(['latest', 'v1', 'v2']).default('v2'),
+    DEEPGRAM_SMART_FORMAT: z.string().default('true'),
     MISTRAL_API_KEY: z.string().optional(),
     MISTRAL_TRANSCRIBE_MODEL: z.string().default('voxtral-mini-latest'),
-    MISTRAL_REALTIME_MODEL: z.string().default('voxtral-mini-transcribe-realtime-2602'),
-    MISTRAL_BASE_URL: z.string().optional(),
     DG_UTT_SPLIT_SEC: z.coerce.number().optional(),
     DG_MERGE_GAP_MS: z.coerce.number().default(800),
     DG_MIN_SEGMENT_MS: z.coerce.number().default(1200),
     DG_USE_PARAGRAPHS: z.string().default('true'),
-    LLM_API_KEY: z.string().optional(),
-    LLM_BASE_URL: z.string().url().optional(),
-    IDENTIFICATION_MODEL: z.string().optional(),
+    ANTHROPIC_API_KEY: z.string().optional(),
+    IDENTIFICATION_MODEL: z.string().optional().default('claude-haiku-4-5'),
     ENABLE_IDENTIFICATION: z.string().default('false'),
 });
-export const ENV = EnvSchema.superRefine((env, ctx) => {
-    const providerKeys = {
-        assemblyai: { path: 'ASSEMBLYAI_API_KEY', label: 'ASSEMBLYAI_API_KEY' },
-        deepgram: { path: 'DEEPGRAM_API_KEY', label: 'DEEPGRAM_API_KEY' },
-        mistral: { path: 'MISTRAL_API_KEY', label: 'MISTRAL_API_KEY' },
-    };
-    for (const key of ['ASSEMBLYAI_API_KEY', 'DEEPGRAM_API_KEY', 'MISTRAL_API_KEY']) {
-        if (env[key] !== undefined && env[key].length === 0) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: [key],
-                message: `${key} must not be empty`,
-            });
-        }
-    }
-    const required = providerKeys[env.TRANSCRIPTION_PROVIDER];
-    if (required && !env[required.path]) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: [required.path],
-            message: `${required.label} is required when TRANSCRIPTION_PROVIDER=${env.TRANSCRIPTION_PROVIDER}`,
-        });
-    }
-}).parse(process.env);
+export const ENV = EnvSchema.parse(process.env);
 export const DEFAULT_DIARIZATION = ENV.DEFAULT_DIARIZATION === 'true';

package/dist/src/{parliament/live → direct}/api.js

@@ -1,5 +1,3 @@
-import { fetchWithRetry } from '../../core/http.js';
-import { reunionOdjTitleFromDataset } from '../odj.js';
 function mustEnv(name) {
     const v = process.env[name];
     if (!v)
@@ -16,9 +14,7 @@ export async function fetchDebatDirect(uid) {
     const url = `${baseUrl}/directs/${encodeURIComponent(uid)}`;
     let res;
     try {
-        res = await fetchWithRetry(`${baseUrl}/directs/${encodeURIComponent(uid)}?include=reunions`, {
-            headers: { 'x-api-token': token },
-        });
+        res = await fetch(url, { headers: { 'x-api-token': token } });
     }
     catch (err) {
         throw new Error(`Network error calling ${url}`, { cause: err });
@@ -40,70 +36,30 @@ export async function fetchDebatDirect(uid) {
         estReplay: d.estReplay ?? false,
         sourceDebatDirectUid: d.sourceDebatDirectUid ?? null,
         titre: d.titre ?? null,
-        reunionUids: (d.reunions ?? []).map((r) => r?.reunionUid).filter(Boolean),
     };
 }
-/** UIDs des réunions liées à un direct (jointure direct→réunion). */
-export async function fetchDirectReunionUids(uid) {
+export async function postParagraphe(uid, p) {
     const { baseUrl, token } = getApiConfig();
-    const res = await fetchWithRetry(`${baseUrl}/directs/${encodeURIComponent(uid)}?include=reunions`, {
-        headers: { 'x-api-token': token },
+    const res = await fetch(`${baseUrl}/paragraphes_directs/${encodeURIComponent(uid)}`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            'x-api-token': token,
+        },
+        body: JSON.stringify(p),
     });
-    if (!res.ok)
-        return [];
-    const json = await res.json().catch(() => null);
-    return (json?.data?.reunions ?? []).map((r) => r?.reunionUid).filter(Boolean);
-}
-/** Contexte LLM d'un direct : titre + ODJ complet de la réunion liée, sans
- *  troncature (rapporteures, auditionnés…). La jointure direct→réunions est
- *  une donnée API (le dataset ne porte pas l'UID du direct) ; l'ODJ lui-même
- *  vient du dataset local (moisson continue — pas de fallback API).
- *  `knownReunionUids` court-circuite la jointure API quand l'appelant les a
- *  déjà (fetchDebatDirect les retourne gratuitement). undefined si la réunion
- *  n'est pas trouvée localement. */
-export async function resolveReunionSessionTitle(uid, dataDir, knownReunionUids) {
-    const reunionUids = knownReunionUids?.length ? knownReunionUids : await fetchDirectReunionUids(uid);
-    const parts = [];
-    for (const ruid of reunionUids.slice(0, 3)) {
-        const title = await reunionOdjTitleFromDataset(ruid, dataDir);
-        if (title)
-            parts.push(title);
-    }
-    return parts.length ? parts.join(' — ') : undefined;
-}
-/** Shared POST against a paragraphes_directs subresource. Sends a JSON body
- *  when provided (flush sends none), and throws with the given error label. */
-async function postDirectsJson(uid, suffix, opts) {
-    const { baseUrl, token } = getApiConfig();
-    const headers = { 'x-api-token': token };
-    if (opts.body !== undefined)
-        headers['content-type'] = 'application/json';
-    let res;
-    try {
-        res = await fetchWithRetry(`${baseUrl}/paragraphes_directs/${encodeURIComponent(uid)}${suffix}`, {
-            method: 'POST',
-            headers,
-            ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
-        });
-    }
-    catch (err) {
-        throw new Error(`${opts.errorLabel} network error`, { cause: err });
-    }
     if (!res.ok) {
         const t = await res.text().catch(() => '');
-        throw new Error(`${opts.errorLabel} failed ${res.status} ${t}`);
+        throw new Error(`API post paragraphe failed ${res.status} ${t}`);
     }
     return res.json().catch(() => ({}));
 }
-export async function postParagraphe(uid, p) {
-    return postDirectsJson(uid, '', { body: p, errorLabel: 'API post paragraphe' });
-}
 export async function createReplayDebatDirect({ sourceUid, videoUrl, startSec, }) {
     const { baseUrl, token } = getApiConfig();
     const url = `${baseUrl}/v2/directs/${encodeURIComponent(sourceUid)}/replay`;
     let res;
     try {
-        res = await fetchWithRetry(url, {
+        res = await fetch(url, {
             method: 'POST',
             headers: {
                 'content-type': 'application/json',
@@ -133,14 +89,41 @@ export async function createReplayDebatDirect({ sourceUid, videoUrl, startSec, }
             titre: data.debatDirect.titre ?? null,
             estReplay: Boolean(data.debatDirect.estReplay),
             sourceDebatDirectUid: String(data.debatDirect.sourceDebatDirectUid),
-            reunionUids: [],
         },
     };
 }
+export async function postUtterance(uid, p) {
+    const { baseUrl, token } = getApiConfig();
+    const res = await fetch(`${baseUrl}/paragraphes_directs/${encodeURIComponent(uid)}/utterance`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            'x-api-token': token,
+        },
+        body: JSON.stringify(p),
+    });
+    if (!res.ok) {
+        const t = await res.text().catch(() => '');
+        throw new Error(`API post utterance failed ${res.status} ${t}`);
+    }
+    return res.json().catch(() => ({}));
+}
+export async function flushUtterancesDraft(uid) {
+    const { baseUrl, token } = getApiConfig();
+    const res = await fetch(`${baseUrl}/paragraphes_directs/${encodeURIComponent(uid)}/flush`, {
+        method: 'POST',
+        headers: { 'x-api-token': token },
+    });
+    if (!res.ok) {
+        const t = await res.text().catch(() => '');
+        throw new Error(`API flush utterances draft failed ${res.status} ${t}`);
+    }
+    return res.json().catch(() => ({}));
+}
 export async function updateDebatDirectIdentification({ uid, newMapping, }) {
     const { baseUrl, token } = getApiConfig();
     try {
-        const res = await fetchWithRetry(`${baseUrl}/v2/directs/${encodeURIComponent(uid)}/identification`, {
+        const res = await fetch(`${baseUrl}/v2/directs/${encodeURIComponent(uid)}/identification`, {
             method: 'PUT',
             body: JSON.stringify({ mapping: newMapping }),
             headers: { 'x-api-token': token, 'Content-Type': 'application/json' },

package/dist/src/{core/ndjson.js → direct/ndjson_tail.js}

@@ -1,27 +1,18 @@
 import fs from 'node:fs';
-import { sleep } from './time.js';
-/** Append one JSON object as a single NDJSON line. */
-export async function appendNdjson(filePath, obj) {
-    await fs.promises.appendFile(filePath, JSON.stringify(obj) + '\n', 'utf8');
-}
-/**
- * Follow a growing NDJSON file, yielding one parsed line at a time (blank
- * lines skipped). Runs until `shouldStop()` returns true — checked after each
- * drain, so already-written lines are emitted before exiting.
- */
 export async function* tailNdjson(path, opts) {
     const pollMs = opts?.pollMs ?? 200;
     let pos = 0;
     let buf = '';
     while (true) {
-        let stat = null;
+        let stat;
         try {
             stat = await fs.promises.stat(path);
         }
         catch {
-            // Fichier pas encore créé : on retente au prochain tour.
+            await new Promise((r) => setTimeout(r, pollMs));
+            continue;
         }
-        if (stat && stat.size > pos) {
+        if (stat.size > pos) {
             const fd = await fs.promises.open(path, 'r');
             try {
                 const len = stat.size - pos;
@@ -42,8 +33,6 @@ export async function* tailNdjson(path, opts) {
                 await fd.close();
             }
         }
-        if (opts?.shouldStop?.())
-            return;
-        await sleep(pollMs);
+        await new Promise((r) => setTimeout(r, pollMs));
     }
 }