@chronicle.app/linkedin 0.3.0

package/dist/connectors/archive/LinkedInArchiveEndorsementsExtractor.d.ts

@@ -0,0 +1,46 @@
+import { Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * Skill endorsements, both directions, merged newest-first:
+ * `Endorsement_Given_Info.csv` and `Endorsement_Received_Info.csv`.
+ *
+ * `direction` records which file a row came from, which is the only thing that
+ * says who vouched for whom — the two files are otherwise identical in shape.
+ *
+ * A row LinkedIn has not marked `ACCEPTED` still describes an endorsement that
+ * happened, so it is extracted like any other. The status itself is a moderation
+ * state rather than history — it can flip long after the act — and the
+ * transformer leaves it off the payload instead of dating today's value to the
+ * day of the endorsement.
+ */
+export declare class LinkedInArchiveEndorsementsExtractor extends LinkedInArchiveExtractor<typeof LinkedInArchiveEndorsementsExtractor> {
+    static description: string;
+    static recordTypes: string[];
+    static defaultTransformer: typeof LinkedInTransformer;
+    static schema: import("zod").ZodObject<{
+        since: import("zod").ZodOptional<import("zod").ZodDate>;
+        until: import("zod").ZodOptional<import("zod").ZodDate>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    } & {
+        input: import("zod").ZodString;
+        'profile-url': import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    extract(): AsyncGenerator<Record>;
+    /** One endorsement file, with the other party's columns read by prefix. */
+    private readEndorsements;
+    determineCount(): Promise<number>;
+}
+//# sourceMappingURL=LinkedInArchiveEndorsementsExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchiveEndorsementsExtractor.js

@@ -0,0 +1,67 @@
+import { memberName, parseSlashStamp, profileHandle, profileUrl } from '../fields.js';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * Skill endorsements, both directions, merged newest-first:
+ * `Endorsement_Given_Info.csv` and `Endorsement_Received_Info.csv`.
+ *
+ * `direction` records which file a row came from, which is the only thing that
+ * says who vouched for whom — the two files are otherwise identical in shape.
+ *
+ * A row LinkedIn has not marked `ACCEPTED` still describes an endorsement that
+ * happened, so it is extracted like any other. The status itself is a moderation
+ * state rather than history — it can flip long after the act — and the
+ * transformer leaves it off the payload instead of dating today's value to the
+ * day of the endorsement.
+ */
+export class LinkedInArchiveEndorsementsExtractor extends LinkedInArchiveExtractor {
+    static description = 'Skill endorsements given and received';
+    static recordTypes = ['endorsements'];
+    static defaultTransformer = LinkedInTransformer;
+    static schema = LinkedInArchiveExtractor.schema;
+    async *extract() {
+        const given = await this.readEndorsements('Endorsement_Given_Info.csv', 'given');
+        const received = await this.readEndorsements('Endorsement_Received_Info.csv', 'received');
+        const endorsements = [...given, ...received].sort((a, b) => (a.endorsedAt ?? '') < (b.endorsedAt ?? '') ? 1 : -1);
+        let count = 0;
+        for (const endorsement of endorsements) {
+            if (this.shouldStopExtracting(count))
+                break;
+            if (!this.withinWindow(endorsement.endorsedAt))
+                continue;
+            yield this.createRecordWithArchiveContext({
+                ...endorsement,
+                occurredAt: endorsement.endorsedAt,
+            });
+            count++;
+        }
+    }
+    /** One endorsement file, with the other party's columns read by prefix. */
+    async readEndorsements(fileName, direction) {
+        const prefix = direction === 'given' ? 'Endorsee' : 'Endorser';
+        const rows = await this.readCsv(fileName);
+        return rows
+            .map(row => {
+            const handle = profileHandle(row[`${prefix} Public Url`]);
+            const name = memberName([row[`${prefix} First Name`], row[`${prefix} Last Name`]]
+                .map(part => part?.trim())
+                .filter(Boolean)
+                .join(' '));
+            return {
+                direction,
+                skill: row['Skill Name']?.trim(),
+                status: row['Endorsement Status']?.trim() || undefined,
+                otherHandle: handle,
+                otherName: name || undefined,
+                otherUrl: handle ? profileUrl(handle) : undefined,
+                endorsedAt: parseSlashStamp(row['Endorsement Date']),
+            };
+        })
+            .filter(row => row.skill && (row.otherHandle || row.otherName));
+    }
+    async determineCount() {
+        const given = await this.readCsv('Endorsement_Given_Info.csv');
+        const received = await this.readCsv('Endorsement_Received_Info.csv');
+        return given.length + received.length;
+    }
+}

package/dist/connectors/archive/LinkedInArchiveExtractor.d.ts

@@ -0,0 +1,120 @@
+import { ArchiveExtractor } from '@chronicle.app/etl';
+import { z } from 'zod';
+/** What one export knows about the member who requested it. */
+export interface LinkedInAccount {
+    /** The vanity slug, when the export names it. */
+    handle?: string;
+    /** `First Last` from Profile.csv, when it has one. */
+    name?: string;
+    /** The address flagged `Primary` in Email Addresses.csv. */
+    email?: string;
+    headline?: string;
+    location?: string;
+}
+/**
+ * Base for the LinkedIn member data export — the ZIP that Settings & Privacy →
+ * Data Privacy → "Get a copy of your data" produces, unpacked to a directory of
+ * CSVs.
+ *
+ * Shared here: reading a named CSV out of the export, the account info every
+ * record carries, and the date window. One subclass per file, because the files
+ * have nothing in common but their extension.
+ *
+ * **Two archives, and this reads either.** The *fast* archive arrives in
+ * minutes with your profile, network, and messages. The *full* archive takes
+ * up to a day and adds your activity — `Shares.csv`, `Comments.csv`,
+ * `Reactions.csv`. Every extractor here treats a missing file as an empty one,
+ * so a fast archive simply yields fewer record types than a full one.
+ */
+export declare abstract class LinkedInArchiveExtractor<T extends typeof LinkedInArchiveExtractor = typeof LinkedInArchiveExtractor> extends ArchiveExtractor<T> {
+    static source: string;
+    static strategy: string;
+    static schema: z.ZodObject<{
+        since: z.ZodOptional<z.ZodDate>;
+        until: z.ZodOptional<z.ZodDate>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    } & {
+        input: z.ZodString;
+        'profile-url': z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    protected accountInfo: LinkedInAccount;
+    /** Lower-cased file name → real file name, so a renamed case still resolves. */
+    private fileIndex?;
+    /** When LinkedIn wrote this export — see {@link asOfTime}. */
+    private compiledAt?;
+    /**
+     * Read the export's own facts before extraction: who it belongs to, and when
+     * LinkedIn built it. The base class defines `loadAccountInfo` but never calls
+     * it — each archive plugin decides when its export is readable.
+     */
+    setup(): Promise<void>;
+    /**
+     * The "as of" time for the snapshot records: when LinkedIn compiled the
+     * export, taken as the newest file time in the directory.
+     *
+     * Not the moment of the import, which is the default. An export is a frozen
+     * artifact — its profile was true when LinkedIn wrote it, not when you got
+     * around to reading it — and dating the sighting to the artifact is also what
+     * makes a second import of the same directory a byte-identical no-op instead
+     * of a fresh sighting of unchanged facts.
+     */
+    protected asOfTime(): Date;
+    /** The newest mtime among the export's files, or none if it has none. */
+    private newestFileTime;
+    /**
+     * The export's own account facts, read once per run: the profile, the primary
+     * email, and — the interesting one — the member's own profile URL.
+     *
+     * **The profile URL is not in Profile.csv.** LinkedIn omits it. It appears
+     * only on the other side of an edge: `Invitations.csv` carries both parties'
+     * URLs *and* a `Direction` column, so an `OUTGOING` row states outright that
+     * the inviter is you. That is the source declaring it, not us guessing from a
+     * name match — and a name match is exactly the guess to avoid, because two
+     * members share a name often enough to matter.
+     *
+     * With no invitations to read, the `profile-url` config supplies it, and
+     * failing that the self falls back to `selfAgent`'s per-source singleton. All
+     * three routes still merge onto the one person through `@me`.
+     */
+    protected loadAccountInfo(): Promise<LinkedInAccount>;
+    /**
+     * The member's own slug, taken from whichever side of an invitation LinkedIn
+     * labelled as theirs. Undefined when the export has no invitations.
+     */
+    private selfHandleFromInvitations;
+    /**
+     * Parse one CSV out of the export, as an array of row objects.
+     *
+     * A file the export did not include comes back empty rather than throwing —
+     * see the fast/full archive note on the class. Every value arrives trimmed,
+     * and `Connections.csv`'s three-line prose preamble is dropped: LinkedIn
+     * writes a `Notes:` paragraph above the header there and nowhere else.
+     */
+    protected readCsv(fileName: string): Promise<Array<{
+        [column: string]: string | undefined;
+    }>>;
+    /** The real path for a file name, matched case-insensitively, or none. */
+    private resolveFile;
+    /** Every file in the export, listed once and indexed for case-insensitive lookup. */
+    private fileNames;
+    /**
+     * Whether a record's date clears the configured since/until window. A record
+     * LinkedIn dated only to the year or month is compared at the start of that
+     * span, and an undated one always passes — dropping it would lose a real
+     * record on the strength of a date the source never wrote.
+     */
+    protected withinWindow(date: string | undefined): boolean;
+}
+//# sourceMappingURL=LinkedInArchiveExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchiveExtractor.js

@@ -0,0 +1,207 @@
+import { ArchiveExtractor, Extractor } from '@chronicle.app/etl';
+import { parse } from 'csv-parse/sync';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { profileHandle } from '../fields.js';
+/**
+ * Base for the LinkedIn member data export — the ZIP that Settings & Privacy →
+ * Data Privacy → "Get a copy of your data" produces, unpacked to a directory of
+ * CSVs.
+ *
+ * Shared here: reading a named CSV out of the export, the account info every
+ * record carries, and the date window. One subclass per file, because the files
+ * have nothing in common but their extension.
+ *
+ * **Two archives, and this reads either.** The *fast* archive arrives in
+ * minutes with your profile, network, and messages. The *full* archive takes
+ * up to a day and adds your activity — `Shares.csv`, `Comments.csv`,
+ * `Reactions.csv`. Every extractor here treats a missing file as an empty one,
+ * so a fast archive simply yields fewer record types than a full one.
+ */
+export class LinkedInArchiveExtractor extends ArchiveExtractor {
+    static source = 'linkedin';
+    static strategy = 'archive';
+    static schema = Extractor.schema.extend({
+        input: z.string().describe('Path to the unpacked LinkedIn export directory'),
+        'profile-url': z
+            .string()
+            .optional()
+            .describe('Your LinkedIn profile URL (https://www.linkedin.com/in/…). Only needed when the export carries no invitation to infer it from.'),
+    });
+    accountInfo = {};
+    /** Lower-cased file name → real file name, so a renamed case still resolves. */
+    fileIndex;
+    /** When LinkedIn wrote this export — see {@link asOfTime}. */
+    compiledAt;
+    /**
+     * Read the export's own facts before extraction: who it belongs to, and when
+     * LinkedIn built it. The base class defines `loadAccountInfo` but never calls
+     * it — each archive plugin decides when its export is readable.
+     */
+    async setup() {
+        await super.setup();
+        this.compiledAt = await this.newestFileTime();
+        await this.loadAccountInfo();
+    }
+    /**
+     * The "as of" time for the snapshot records: when LinkedIn compiled the
+     * export, taken as the newest file time in the directory.
+     *
+     * Not the moment of the import, which is the default. An export is a frozen
+     * artifact — its profile was true when LinkedIn wrote it, not when you got
+     * around to reading it — and dating the sighting to the artifact is also what
+     * makes a second import of the same directory a byte-identical no-op instead
+     * of a fresh sighting of unchanged facts.
+     */
+    asOfTime() {
+        return this.compiledAt ?? super.asOfTime();
+    }
+    /** The newest mtime among the export's files, or none if it has none. */
+    async newestFileTime() {
+        const { input } = this.config;
+        let newest;
+        for (const name of await this.fileNames()) {
+            try {
+                const { mtimeMs } = await stat(join(input, name));
+                if (newest === undefined || mtimeMs > newest)
+                    newest = mtimeMs;
+            }
+            catch {
+                // A file that vanished between listing and stat tells us nothing.
+            }
+        }
+        return newest === undefined ? undefined : new Date(newest);
+    }
+    /**
+     * The export's own account facts, read once per run: the profile, the primary
+     * email, and — the interesting one — the member's own profile URL.
+     *
+     * **The profile URL is not in Profile.csv.** LinkedIn omits it. It appears
+     * only on the other side of an edge: `Invitations.csv` carries both parties'
+     * URLs *and* a `Direction` column, so an `OUTGOING` row states outright that
+     * the inviter is you. That is the source declaring it, not us guessing from a
+     * name match — and a name match is exactly the guess to avoid, because two
+     * members share a name often enough to matter.
+     *
+     * With no invitations to read, the `profile-url` config supplies it, and
+     * failing that the self falls back to `selfAgent`'s per-source singleton. All
+     * three routes still merge onto the one person through `@me`.
+     */
+    async loadAccountInfo() {
+        const account = {};
+        const [profile] = await this.readCsv('Profile.csv');
+        if (profile) {
+            const name = [profile['First Name'], profile['Last Name']]
+                .map(part => part?.trim())
+                .filter(Boolean)
+                .join(' ');
+            if (name)
+                account.name = name;
+            if (profile.Headline?.trim())
+                account.headline = profile.Headline.trim();
+            if (profile['Geo Location']?.trim()) {
+                account.location = profile['Geo Location'].trim();
+            }
+        }
+        const emails = await this.readCsv('Email Addresses.csv');
+        const primary = emails.find(row => row.Primary?.trim() === 'Yes');
+        const email = primary?.['Email Address']?.trim();
+        if (email)
+            account.email = email;
+        const configured = profileHandle(this.config['profile-url']);
+        account.handle = configured ?? (await this.selfHandleFromInvitations());
+        this.accountInfo = account;
+        return account;
+    }
+    /**
+     * The member's own slug, taken from whichever side of an invitation LinkedIn
+     * labelled as theirs. Undefined when the export has no invitations.
+     */
+    async selfHandleFromInvitations() {
+        const invitations = await this.readCsv('Invitations.csv');
+        for (const row of invitations) {
+            const direction = row.Direction?.trim().toUpperCase();
+            if (direction === 'OUTGOING') {
+                const handle = profileHandle(row.inviterProfileUrl);
+                if (handle)
+                    return handle;
+            }
+            if (direction === 'INCOMING') {
+                const handle = profileHandle(row.inviteeProfileUrl);
+                if (handle)
+                    return handle;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Parse one CSV out of the export, as an array of row objects.
+     *
+     * A file the export did not include comes back empty rather than throwing —
+     * see the fast/full archive note on the class. Every value arrives trimmed,
+     * and `Connections.csv`'s three-line prose preamble is dropped: LinkedIn
+     * writes a `Notes:` paragraph above the header there and nowhere else.
+     */
+    async readCsv(fileName) {
+        const path = await this.resolveFile(fileName);
+        if (!path)
+            return [];
+        const text = stripPreamble(await readFile(path, 'utf8'));
+        if (!text.trim())
+            return [];
+        return parse(text, {
+            columns: (header) => header.map(column => column.trim()),
+            skip_empty_lines: true,
+            relax_column_count: true,
+            trim: true,
+            bom: true,
+        });
+    }
+    /** The real path for a file name, matched case-insensitively, or none. */
+    async resolveFile(fileName) {
+        await this.fileNames();
+        const resolved = this.fileIndex.get(fileName.toLowerCase());
+        const { input } = this.config;
+        return resolved ? join(input, resolved) : undefined;
+    }
+    /** Every file in the export, listed once and indexed for case-insensitive lookup. */
+    async fileNames() {
+        if (!this.fileIndex) {
+            const { input } = this.config;
+            let entries = [];
+            try {
+                entries = await readdir(input);
+            }
+            catch {
+                throw new Error(`Could not read the LinkedIn export directory ${input}`);
+            }
+            this.fileIndex = new Map(entries.map(name => [name.toLowerCase(), name]));
+        }
+        return [...this.fileIndex.values()];
+    }
+    /**
+     * Whether a record's date clears the configured since/until window. A record
+     * LinkedIn dated only to the year or month is compared at the start of that
+     * span, and an undated one always passes — dropping it would lose a real
+     * record on the strength of a date the source never wrote.
+     */
+    withinWindow(date) {
+        if (!date)
+            return true;
+        const parsed = new Date(date);
+        return Number.isNaN(parsed.getTime()) ? true : this.isWithinDateRange(parsed);
+    }
+}
+/**
+ * Drop the prose LinkedIn writes above the header of `Connections.csv` — a
+ * `Notes:` line, a quoted paragraph about missing email addresses, then a blank
+ * line. Detected by that literal opener rather than by counting lines, so a
+ * longer or shorter note still parses.
+ */
+function stripPreamble(text) {
+    if (!text.startsWith('Notes:'))
+        return text;
+    const blankLine = /\r?\n\s*\r?\n/.exec(text);
+    return blankLine ? text.slice(blankLine.index + blankLine[0].length) : text;
+}

package/dist/connectors/archive/LinkedInArchiveFollowsExtractor.d.ts

@@ -0,0 +1,39 @@
+import { Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Company Follows.csv` — the organizations and topic pages you follow, with
+ * the moment you followed each, newest-first.
+ *
+ * LinkedIn files a topic page ("Scrum", "Web Development") in the same list as
+ * a real employer, and gives neither an id — the organization's display name is
+ * all we get, so it is what the follow points at.
+ */
+export declare class LinkedInArchiveFollowsExtractor extends LinkedInArchiveExtractor<typeof LinkedInArchiveFollowsExtractor> {
+    static description: string;
+    static recordTypes: string[];
+    static defaultTransformer: typeof LinkedInTransformer;
+    static schema: import("zod").ZodObject<{
+        since: import("zod").ZodOptional<import("zod").ZodDate>;
+        until: import("zod").ZodOptional<import("zod").ZodDate>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    } & {
+        input: import("zod").ZodString;
+        'profile-url': import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    extract(): AsyncGenerator<Record>;
+    determineCount(): Promise<number>;
+}
+//# sourceMappingURL=LinkedInArchiveFollowsExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchiveFollowsExtractor.js

@@ -0,0 +1,42 @@
+import { parseLongStamp } from '../fields.js';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Company Follows.csv` — the organizations and topic pages you follow, with
+ * the moment you followed each, newest-first.
+ *
+ * LinkedIn files a topic page ("Scrum", "Web Development") in the same list as
+ * a real employer, and gives neither an id — the organization's display name is
+ * all we get, so it is what the follow points at.
+ */
+export class LinkedInArchiveFollowsExtractor extends LinkedInArchiveExtractor {
+    static description = 'Companies you follow';
+    static recordTypes = ['follows'];
+    static defaultTransformer = LinkedInTransformer;
+    static schema = LinkedInArchiveExtractor.schema;
+    async *extract() {
+        const rows = await this.readCsv('Company Follows.csv');
+        const follows = rows
+            .map(row => ({
+            organization: row.Organization?.trim(),
+            followedAt: parseLongStamp(row['Followed On']),
+        }))
+            .filter(follow => follow.organization)
+            .sort((a, b) => ((a.followedAt ?? '') < (b.followedAt ?? '') ? 1 : -1));
+        let count = 0;
+        for (const follow of follows) {
+            if (this.shouldStopExtracting(count))
+                break;
+            if (!this.withinWindow(follow.followedAt))
+                continue;
+            yield this.createRecordWithArchiveContext({
+                ...follow,
+                occurredAt: follow.followedAt,
+            });
+            count++;
+        }
+    }
+    async determineCount() {
+        return (await this.readCsv('Company Follows.csv')).length;
+    }
+}

package/dist/connectors/archive/LinkedInArchiveLearningExtractor.d.ts

@@ -0,0 +1,41 @@
+import { Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Learning.csv` — LinkedIn Learning courses, newest-watched first.
+ *
+ * Stays `event` rather than `snapshot`. The row re-reports one moving value,
+ * the last time you watched, and each export pins that value to a real date —
+ * so successive exports accumulate the distinct sittings instead of one
+ * attribute overwriting itself.
+ *
+ * LinkedIn writes `N/A` where it means "never", which is not a date.
+ */
+export declare class LinkedInArchiveLearningExtractor extends LinkedInArchiveExtractor<typeof LinkedInArchiveLearningExtractor> {
+    static description: string;
+    static recordTypes: string[];
+    static defaultTransformer: typeof LinkedInTransformer;
+    static schema: import("zod").ZodObject<{
+        since: import("zod").ZodOptional<import("zod").ZodDate>;
+        until: import("zod").ZodOptional<import("zod").ZodDate>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    } & {
+        input: import("zod").ZodString;
+        'profile-url': import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    extract(): AsyncGenerator<Record>;
+    determineCount(): Promise<number>;
+}
+//# sourceMappingURL=LinkedInArchiveLearningExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchiveLearningExtractor.js

@@ -0,0 +1,46 @@
+import { parseSpaceStamp } from '../fields.js';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Learning.csv` — LinkedIn Learning courses, newest-watched first.
+ *
+ * Stays `event` rather than `snapshot`. The row re-reports one moving value,
+ * the last time you watched, and each export pins that value to a real date —
+ * so successive exports accumulate the distinct sittings instead of one
+ * attribute overwriting itself.
+ *
+ * LinkedIn writes `N/A` where it means "never", which is not a date.
+ */
+export class LinkedInArchiveLearningExtractor extends LinkedInArchiveExtractor {
+    static description = 'LinkedIn Learning courses watched or saved';
+    static recordTypes = ['learning'];
+    static defaultTransformer = LinkedInTransformer;
+    static schema = LinkedInArchiveExtractor.schema;
+    async *extract() {
+        const rows = await this.readCsv('Learning.csv');
+        const courses = rows
+            .map(row => ({
+            title: row['Content Title']?.trim(),
+            description: row['Content Description']?.trim() || undefined,
+            contentType: row['Content Type']?.trim() || undefined,
+            watchedAt: parseSpaceStamp(row['Content Last Watched Date (if viewed)']),
+            completedAt: parseSpaceStamp(row['Content Completed At (if completed)']),
+            saved: row['Content Saved']?.trim().toLowerCase() === 'true',
+        }))
+            .filter(course => course.title)
+            .sort((a, b) => ((a.watchedAt ?? '') < (b.watchedAt ?? '') ? 1 : -1));
+        let count = 0;
+        for (const course of courses) {
+            if (this.shouldStopExtracting(count))
+                break;
+            const occurredAt = course.watchedAt ?? course.completedAt;
+            if (!this.withinWindow(occurredAt))
+                continue;
+            yield this.createRecordWithArchiveContext({ ...course, occurredAt });
+            count++;
+        }
+    }
+    async determineCount() {
+        return (await this.readCsv('Learning.csv')).length;
+    }
+}