@tricoteuses/senat 3.2.1 → 3.2.3

package/lib/src/types/compte_rendu.d.ts

@@ -0,0 +1,83 @@
+export interface CompteRendu {
+    uid: string;
+    seanceRef: string;
+    sessionRef: string;
+    metadonnees: Metadonnees;
+    contenu: Contenu;
+}
+export interface Metadonnees {
+    dateSeance: string;
+    dateSeanceJour: string;
+    numSeanceJour: string;
+    numSeance: string;
+    typeAssemblee: "AN" | "SN";
+    legislature: string;
+    session: string;
+    nomFichierJo: string;
+    validite: string;
+    etat: string;
+    diffusion: string;
+    version: string;
+    environnement: string;
+    heureGeneration: Date;
+    sommaire?: Sommaire;
+}
+export interface Contenu {
+    quantiemes: Quantiemes;
+    ouvertureSeance?: Point[] | Point;
+    point: Point[] | Point;
+    finSeance?: FinSeance;
+    paragraphe?: Point[];
+}
+export interface FinSeance {
+    point: Point;
+}
+export interface Quantiemes {
+    journee: string;
+    session: string;
+}
+export interface Point {
+    ordre_absolu_seance: string;
+    code_grammaire: string;
+    roledebat?: string;
+    orateurs?: {
+        orateur: {
+            nom: string;
+            id: string;
+            qualite: string;
+        };
+    };
+    texte: {
+        _: string;
+    };
+    code_style?: string;
+}
+export interface Texte {
+    _?: string;
+    id_syceron?: string;
+    stime?: string;
+    sup?: string;
+    lienAdt?: Texte[] | Texte;
+}
+export interface Sommaire {
+    presidentSeance: Texte;
+    sommaire1: SommaireElement[] | SommaireElement;
+    sommaire3?: SommaireElement[] | SommaireElement;
+    sommaire2?: SommaireElement[] | SommaireElement;
+    para?: Texte[] | Texte;
+}
+export interface SommaireElement {
+    valeur_pts_odj: string | undefined;
+    titreStruct: TitreStruct;
+    para?: Array<Texte | string> | Texte;
+    sommaire2?: SommaireElement[] | SommaireElement;
+    sommaire3?: SommaireElement[] | SommaireElement;
+    presidentSeance?: Texte[] | Texte;
+    type_debat?: string;
+}
+export interface TitreStruct {
+    id_syceron: string;
+    intitule?: string;
+    sousIntitule?: string;
+    type_debat?: string;
+}

package/lib/src/types/compte_rendu.js

@@ -0,0 +1 @@
+export {};

package/lib/src/types/debats.d.ts

@@ -0,0 +1,2 @@
+import { debats as Debat, lecassdeb as LecAssDeb } from "../raw_types_schemats/debats";
+export type { Debat, LecAssDeb };

package/lib/src/types/debats.js

@@ -0,0 +1 @@
+export {};

package/lib/src/types/dosleg.d.ts

@@ -0,0 +1,70 @@
+import { Ass, Aud as AudRaw, Auteur as AuteurRaw, DateSeance as DateSeanceRaw, Deccoc, Denrap, Docatt as DocattRaw, Ecr as EcrRaw, Etaloi, Lecass as LecassRaw, Lecassrap as LecassrapRaw, Lecture as LectureRaw, Loi as LoiRaw, Org, Oritxt, Qua, Rap as RapRaw, Raporg, Scr, Texte as TexteRaw, Typatt, Typlec, Typloi, Typtxt, Typurl } from "../raw_types/dosleg.js";
+import { TxtAmeli } from "../raw_types/ameli.js";
+import { Debats } from "../raw_types/debats.js";
+import { TxtAmeliCustom } from "./ameli.js";
+export type { Deccoc as DecCoc, Denrap as DenRap, Etaloi as EtaLoi, Oritxt as OriTxt, Raporg as RapOrg, Typatt as TypAtt, Typlec as TypLec, Typloi as TypLoi, Typtxt as TypTxt, Typurl as TypUrl, };
+export interface Aud extends AudRaw {
+    org?: Org;
+}
+export interface Auteur extends AuteurRaw {
+    qua?: Qua;
+}
+export interface DateSeance extends DateSeanceRaw {
+    debat?: Debats;
+    scrids?: string[];
+    scrs?: Scr[];
+}
+export interface DocAtt extends DocattRaw {
+    rap?: RapRaw;
+    typatt?: Typatt;
+}
+export interface Ecr extends EcrRaw {
+    aut?: Auteur;
+}
+export interface LecAss extends LecassRaw {
+    ass?: Ass;
+    auds?: Aud[];
+    audcles?: AudRaw["audcle"][];
+    datesSeances?: DateSeance[];
+    datesSeancesCodes?: DateSeanceRaw["code"][];
+    debatdatseas: Date[];
+    lecassraps?: LecAssRap[];
+    lecassrapids?: string[];
+    org?: Org;
+    texcods: TexteRaw["texcod"][];
+    textes?: Texte[];
+}
+export interface LecAssRap extends LecassrapRaw {
+    rap?: RapRaw;
+}
+export interface Lecture extends LectureRaw {
+    typlec?: Typlec;
+    lecassidts?: LecassRaw["lecassidt"][];
+    lecasss?: LecAss[];
+}
+export interface Loi extends LoiRaw {
+    deccoc?: Deccoc;
+    etaloi?: Etaloi;
+    lecidts?: LectureRaw["lecidt"][];
+    lectures?: Lecture[];
+    typloi?: Typloi;
+}
+export interface Rap extends RapRaw {
+    denrap?: Denrap;
+    docattcles?: DocattRaw["docattcle"][];
+    docatts?: DocAtt[];
+    ecrnums?: EcrRaw["ecrnum"][];
+    ecrs?: Ecr[];
+    orgcods?: Raporg["orgcod"][];
+    orgs?: Org[];
+}
+export interface Texte extends TexteRaw {
+    ecrs?: Ecr[];
+    ecrnums?: EcrRaw["ecrnum"][];
+    libtypurl?: Typurl["libtypurl"];
+    org?: Org;
+    oritxt: Oritxt;
+    typtxt?: Typtxt;
+    txtAmeli?: TxtAmeliCustom;
+    txtAmeliId: TxtAmeli["id"];
+}

package/lib/src/types/dosleg.js

@@ -0,0 +1 @@
+export {};

package/lib/src/types/questions.d.ts

@@ -0,0 +1,2 @@
+import { TamQuestions } from "../raw_types/questions.js";
+export type { TamQuestions as Question };

package/lib/src/types/questions.js

@@ -0,0 +1 @@
+export {};

package/lib/src/types/sens.d.ts

@@ -0,0 +1,8 @@
+export interface Photo {
+    chemin: string;
+    cheminMosaique: string;
+    hauteur: number;
+    largeur: number;
+    xMosaique: number;
+    yMosaique: number;
+}

package/lib/src/types/sens.js

@@ -0,0 +1 @@
+export {};

package/lib/src/types/sessions.d.ts

@@ -0,0 +1,6 @@
+export declare const UNDEFINED_SESSION = 0;
+export declare const sessionOptions: readonly [1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026];
+export declare const sessionOptionsOrAll: readonly [0, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026];
+export type Session = (typeof sessionOptions)[number];
+export type SessionOrAll = (typeof sessionOptionsOrAll)[number];
+export declare function getSessionsFromStart(startSession: SessionOrAll): (1958 | 1959 | 1960 | 1961 | 1962 | 1963 | 1964 | 1965 | 1966 | 1967 | 1968 | 1969 | 1970 | 1971 | 1972 | 1973 | 1974 | 1975 | 1976 | 1977 | 1978 | 1979 | 1980 | 1981 | 1982 | 1983 | 1984 | 1985 | 1986 | 1987 | 1988 | 1989 | 1990 | 1991 | 1992 | 1993 | 1994 | 1995 | 1996 | 1997 | 1998 | 1999 | 2000 | 2001 | 2002 | 2003 | 2004 | 2005 | 2006 | 2007 | 2008 | 2009 | 2010 | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026)[];

package/lib/src/types/sessions.js

@@ -0,0 +1,19 @@
+export const UNDEFINED_SESSION = 0;
+export const sessionOptions = [
+    1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976,
+    1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014,
+    2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026,
+    // TO COMPLETE EVERY YEAR :)
+];
+export const sessionOptionsOrAll = [UNDEFINED_SESSION, ...sessionOptions];
+export function getSessionsFromStart(startSession) {
+    if (startSession === UNDEFINED_SESSION) {
+        return Array.from(sessionOptions);
+    }
+    const sessionIndex = sessionOptions.findIndex((session) => startSession === session);
+    if (sessionIndex >= 0) {
+        return sessionOptions.slice(sessionIndex);
+    }
+    return [];
+}

package/lib/src/types/texte.d.ts

@@ -0,0 +1,72 @@
+import { DocumentResult } from "../loaders.js";
+export declare enum DivisionType {
+    tome = 1,
+    part = 2,
+    book = 3,
+    title = 4,
+    subtitle = 5,
+    chapter = 6,
+    section = 7,
+    subsection = 8,
+    paragraph = 9,
+    article = 10,
+    alinea = 11,
+    division = 12
+}
+export type DivisionTag = keyof typeof DivisionType;
+export interface DocumentMetadata {
+    name: string;
+    session: number | null | undefined;
+    date?: string | null;
+    url_expose_des_motifs?: URL;
+    url_xml?: URL;
+    url_html: URL;
+    url_pdf: URL;
+}
+export interface FlatTexte extends Partial<DocumentResult> {
+    titre: string | null;
+    titre_court: string | null;
+    url_dossier_senat: string | null;
+    url_dossier_assemblee: string | null;
+    date_presentation: Date | null;
+    date_depot: Date | null;
+    date_publication_xml: Date | null;
+    version: Version | null;
+    divisions: Division[];
+    expose_motifs?: ExposeDesMotifs | null;
+}
+export type Version = "RECT" | "RECT_BIS" | "RECT_TER" | "RECT_QUATER" | "RECT_QUINQUIES";
+export interface Step {
+    eId: string;
+    date: Date | null;
+    type: string | null;
+    session: string | null;
+    numero: string | null;
+    version: Version | null;
+    outcome: string | null;
+}
+export interface Division {
+    index: number;
+    eId: string;
+    tag: DivisionTag;
+    level: number;
+    headings: DivisionContent[];
+}
+export interface Article extends Division {
+    alineas: Alinea[];
+}
+export interface DivisionContent {
+    text: string | null;
+    html?: string | null;
+}
+export interface Alinea extends DivisionContent {
+    eId: string;
+    heading: DivisionContent;
+    pastille: string | null;
+    text_avec_liens?: string | null;
+    html_avec_liens?: string | null;
+}
+export interface ExposeDesMotifs {
+    text: string | null;
+    html: string | null;
+}

package/lib/src/types/texte.js

@@ -0,0 +1,15 @@
+export var DivisionType;
+(function (DivisionType) {
+    DivisionType[DivisionType["tome"] = 1] = "tome";
+    DivisionType[DivisionType["part"] = 2] = "part";
+    DivisionType[DivisionType["book"] = 3] = "book";
+    DivisionType[DivisionType["title"] = 4] = "title";
+    DivisionType[DivisionType["subtitle"] = 5] = "subtitle";
+    DivisionType[DivisionType["chapter"] = 6] = "chapter";
+    DivisionType[DivisionType["section"] = 7] = "section";
+    DivisionType[DivisionType["subsection"] = 8] = "subsection";
+    DivisionType[DivisionType["paragraph"] = 9] = "paragraph";
+    DivisionType[DivisionType["article"] = 10] = "article";
+    DivisionType[DivisionType["alinea"] = 11] = "alinea";
+    DivisionType[DivisionType["division"] = 12] = "division";
+})(DivisionType || (DivisionType = {}));

package/lib/src/validators/config.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const configSchema: z.ZodObject<{
+    db: z.ZodObject<{
+        host: z.ZodString;
+        password: z.ZodString;
+        user: z.ZodString;
+        port: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/lib/src/validators/config.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+const dbSchema = z.object({
+    host: z.string().trim().min(1, "Must not be empty"),
+    password: z.string().trim().min(1, "Must not be empty"),
+    user: z.string().trim().min(1, "Must not be empty"),
+    port: z.coerce.number().int().min(0).max(65535),
+});
+export const configSchema = z.object({
+    db: dbSchema,
+});

package/lib/src/videos/match.js

@@ -98,16 +98,16 @@ export async function matchOneReunion(args) {
     // Accept threshold (best must pass)
     if (best.score < minAccept) {
         if (!options["silent"])
-            console.log(`[threshold] ${agenda.uid} score=${best.score.toFixed(2)}
-          agenda title="${agenda.titre ?? ""}"
+            console.log(`[threshold] ${agenda.uid} score=${best.score.toFixed(2)}
+          agenda title="${agenda.titre ?? ""}"
           best title="${best.vtitle ?? ""}"`);
         return null;
     }
     // Margin (confidence) gate
     if (second && best.score - second.score < margin) {
         if (!options["silent"]) {
-            console.log(`[Margin] ${agenda.uid} score=${best.score.toFixed(2)}
-          agenda title="${agenda.titre ?? ""}" agenda date="${agenda.startTime ?? ""}"
+            console.log(`[Margin] ${agenda.uid} score=${best.score.toFixed(2)}
+          agenda title="${agenda.titre ?? ""}" agenda date="${agenda.startTime ?? ""}"
           best title="${best.vtitle ?? ""}" date="${best.epoch ? new Date(best.epoch * 1000).toISOString() : "null"}"`);
             console.log("second title=", second.vtitle ?? "", " score=", second.score.toFixed(2), "date=", second.epoch ? new Date(second.epoch * 1000).toISOString() : "null");
         }

package/lib/tests/dataDownload.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/dataDownload.test.js

@@ -0,0 +1,217 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { forwardArgs, parseArgs, readStatusFile, recordFailure, recordSuccess, runDataDownload, STATUS_FILENAME, writeStatusFile, } from "../src/scripts/shared/data_download.js";
+let dataDir;
+afterEach(() => {
+    if (dataDir !== undefined) {
+        rmSync(dataDir, { force: true, recursive: true });
+    }
+});
+function createTempDataDir() {
+    dataDir = mkdtempSync(path.join(tmpdir(), "senat-data-download-"));
+    return dataDir;
+}
+const fixedDate = new Date("2026-09-08T10:00:00Z");
+function makeExec(respond) {
+    const commands = [];
+    return {
+        commands,
+        exec: (command) => {
+            commands.push(command);
+            return respond(command) ?? { status: 0 };
+        },
+    };
+}
+describe("parseArgs", () => {
+    it("defaults categories to All when none are provided", () => {
+        const parsed = parseArgs([]);
+        expect(parsed.categories).toEqual(["All"]);
+        expect(parsed.dataDir).toBeUndefined();
+        expect(parsed.rest).toEqual([]);
+    });
+    it("extracts the dataDir positional argument and forwards the other options", () => {
+        const rawArgs = [
+            "--all",
+            "/app/senat-data",
+            "--fromSession",
+            "2022",
+            "--fetchDocuments",
+            "--parseDocuments",
+            "--only-recent",
+            "30",
+            "--commit",
+            "--keepDir",
+        ];
+        const parsed = parseArgs(rawArgs);
+        expect(parsed.dataDir).toBe("/app/senat-data");
+        expect(parsed.rest).toEqual([
+            "--all",
+            "--fromSession",
+            "2022",
+            "--fetchDocuments",
+            "--parseDocuments",
+            "--only-recent",
+            "30",
+            "--commit",
+            "--keepDir",
+        ]);
+    });
+    it("collects --categories values including repeated occurrences", () => {
+        const parsed = parseArgs(["/data", "--categories", "Ameli", "--categories", "Sens"]);
+        expect(parsed.categories).toEqual(["Ameli", "Sens"]);
+        expect(parsed.dataDir).toBe("/data");
+        expect(parsed.rest).toEqual([]);
+    });
+    it("supports the -k alias and comma-separated values", () => {
+        const parsed = parseArgs(["-k", "Sens,Ameli", "/data"]);
+        expect(parsed.categories).toEqual(["Sens", "Ameli"]);
+    });
+    it("supports the --categories= form", () => {
+        const parsed = parseArgs(["--categories=Sens", "/data"]);
+        expect(parsed.categories).toEqual(["Sens"]);
+    });
+    it("does not mistake valued options for the dataDir positional", () => {
+        const parsed = parseArgs(["--sudo", "postgres", "--remote", "origin", "true-data", "--verbose"]);
+        expect(parsed.dataDir).toBe("true-data");
+        expect(parsed.rest).toEqual(["--sudo", "postgres", "--remote", "origin", "--verbose"]);
+    });
+});
+describe("forwardArgs", () => {
+    it("appends the dataDir then the requested categories to the forwarded options", () => {
+        const parsed = parseArgs(["--all", "/app/senat-data", "--categories", "All", "--fromSession", "2022"]);
+        const forwarded = forwardArgs(parsed, ["Sens"]);
+        expect(forwarded).toBe("--all --fromSession 2022 /app/senat-data --categories Sens");
+    });
+});
+describe("dataset status file", () => {
+    it("increments consecutiveFailures and keeps firstFailureAt across consecutive failures", () => {
+        const statuses = {};
+        recordFailure(statuses, "sens", new Date("2026-09-01T00:00:00Z"), "dump empty");
+        recordFailure(statuses, "sens", new Date("2026-09-02T00:00:00Z"), "dump empty again");
+        expect(statuses["sens"]).toMatchObject({
+            status: "failed",
+            consecutiveFailures: 2,
+            firstFailureAt: "2026-09-01T00:00:00.000Z",
+            lastFailureAt: "2026-09-02T00:00:00.000Z",
+            lastError: "dump empty again",
+            lastSuccessAt: undefined,
+        });
+    });
+    it("resets the failure streak on success while updating lastSuccessAt", () => {
+        const statuses = {};
+        recordFailure(statuses, "sens", new Date("2026-09-01T00:00:00Z"), "dump empty");
+        recordSuccess(statuses, "sens", new Date("2026-09-02T00:00:00Z"));
+        expect(statuses["sens"]).toEqual({
+            status: "ok",
+            consecutiveFailures: 0,
+            lastRunAt: "2026-09-02T00:00:00.000Z",
+            lastSuccessAt: "2026-09-02T00:00:00.000Z",
+        });
+    });
+    it("returns an empty state for a missing or corrupted status file", () => {
+        const dir = createTempDataDir();
+        expect(readStatusFile(path.join(dir, STATUS_FILENAME))).toEqual({});
+        const corruptedPath = path.join(dir, "corrupted.json");
+        writeFileSync(corruptedPath, "{not json", { encoding: "utf-8" });
+        expect(readStatusFile(corruptedPath)).toEqual({});
+    });
+    it("round-trips statuses through the status file", () => {
+        const dir = createTempDataDir();
+        const filePath = path.join(dir, STATUS_FILENAME);
+        const statuses = {};
+        recordFailure(statuses, "sens", fixedDate, "dump empty");
+        writeStatusFile(filePath, statuses);
+        expect(readStatusFile(filePath)).toEqual(statuses);
+    });
+});
+describe("runDataDownload", () => {
+    it("continues after a dataset failure, converts only successful categories and exits 0", () => {
+        const dir = createTempDataDir();
+        const { commands, exec } = makeExec((command) => command.includes("--categories Sens")
+            ? { status: 1, error: new Error("Staging schema sens_staging is empty") }
+            : undefined);
+        const exitCode = runDataDownload({
+            rawArgs: [dir, "--fromSession", "2022"],
+            exec,
+            now: () => fixedDate,
+        });
+        expect(exitCode).toBe(0);
+        const retrieveCommands = commands.filter((command) => command.includes("retrieve_open_data"));
+        expect(retrieveCommands).toHaveLength(5);
+        for (const command of retrieveCommands) {
+            expect(command).toContain("retrieve_open_data.ts --all ");
+        }
+        expect(retrieveCommands[0]).toContain("--categories Ameli");
+        expect(retrieveCommands[4]).toContain("--categories Sens");
+        const convertCommand = commands.find((command) => command.includes("convert_data"));
+        expect(convertCommand).toContain("--categories Ameli");
+        expect(convertCommand).toContain("--categories Debats");
+        expect(convertCommand).toContain("--categories DosLeg");
+        expect(convertCommand).toContain("--categories Questions");
+        expect(convertCommand).not.toContain("--categories Sens");
+        const agendaCommand = commands.find((command) => command.includes("retrieve_agenda"));
+        expect(agendaCommand).toBe(`cross-env TZ='Etc/UTC' tsx src/scripts/retrieve_agenda.ts ${dir} --fromSession 2022 --parseAgenda --silent`);
+        const statuses = JSON.parse(readFileSync(path.join(dir, STATUS_FILENAME), { encoding: "utf-8" }));
+        expect(statuses.sens).toMatchObject({ status: "failed", consecutiveFailures: 1 });
+        expect(statuses.ameli).toMatchObject({ status: "ok", consecutiveFailures: 0 });
+    });
+    it("exits 1 without conversion when all datasets fail", () => {
+        const dir = createTempDataDir();
+        const { commands, exec } = makeExec(() => ({ status: 1, error: new Error("boom") }));
+        const exitCode = runDataDownload({
+            rawArgs: [dir],
+            exec,
+            now: () => fixedDate,
+        });
+        expect(exitCode).toBe(1);
+        expect(commands.filter((command) => command.includes("retrieve_open_data"))).toHaveLength(5);
+        expect(commands.find((command) => command.includes("convert_data"))).toBeUndefined();
+        expect(commands.find((command) => command.includes("retrieve_agenda"))).toBeUndefined();
+        const statuses = JSON.parse(readFileSync(path.join(dir, STATUS_FILENAME), { encoding: "utf-8" }));
+        for (const dataset of ["ameli", "debats", "dosleg", "questions", "sens"]) {
+            expect(statuses[dataset]).toMatchObject({ status: "failed", consecutiveFailures: 1 });
+        }
+    });
+    it("runs every step when all datasets succeed", () => {
+        const dir = createTempDataDir();
+        const { commands, exec } = makeExec(() => undefined);
+        const exitCode = runDataDownload({
+            rawArgs: [dir, "--categories", "All"],
+            exec,
+            now: () => fixedDate,
+        });
+        expect(exitCode).toBe(0);
+        const convertCommand = commands.find((command) => command.includes("convert_data"));
+        for (const category of ["Ameli", "Debats", "DosLeg", "Questions", "Sens"]) {
+            expect(convertCommand).toContain(`--categories ${category}`);
+        }
+        expect(commands.find((command) => command.includes("retrieve_agenda"))).toBeDefined();
+        expect(commands.find((command) => command.includes("retrieve_cr_seance"))).toBeDefined();
+        expect(commands.find((command) => command.includes("retrieve_cr_commission"))).toBeDefined();
+        expect(commands.find((command) => command.includes("retrieve_videos"))).toBeDefined();
+        expect(commands.find((command) => command.includes("retrieve_collaborateurs"))).toBeDefined();
+    });
+    it("stops after convert_data when it fails and propagates its exit status", () => {
+        const dir = createTempDataDir();
+        const { commands, exec } = makeExec((command) => command.includes("convert_data") ? { status: 3, error: new Error("parse failure") } : undefined);
+        const exitCode = runDataDownload({
+            rawArgs: [dir],
+            exec,
+            now: () => fixedDate,
+        });
+        expect(exitCode).toBe(3);
+        expect(commands.find((command) => command.includes("retrieve_agenda"))).toBeUndefined();
+    });
+    it("exits 1 when no requested category matches a known dataset", () => {
+        const { commands, exec } = makeExec(() => undefined);
+        const exitCode = runDataDownload({
+            rawArgs: ["/data", "--categories", "Unknown"],
+            exec,
+            now: () => fixedDate,
+        });
+        expect(exitCode).toBe(1);
+        expect(commands).toHaveLength(0);
+    });
+});

package/lib/tests/parsers/plf/amendement.test.d.ts

@@ -0,0 +1 @@
+export {};