@chronicle.app/linkedin 0.3.0

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

@@ -0,0 +1,63 @@
+import { Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/** A party to a message: the handle when LinkedIn gave one, the name when it did not. */
+export interface MessageParty {
+    handle?: string;
+    name?: string;
+    url?: string;
+}
+/**
+ * `messages.csv` — every LinkedIn message, newest-first, grouped by the
+ * conversation id LinkedIn assigns.
+ *
+ * **Names and profile URLs cannot be zipped together.** A group thread lists
+ * every participant's name in `TO` but only publishes URLs for the ones you may
+ * see, so the two comma-separated lists routinely differ in length and the
+ * n-th name is not the n-th URL. Pairing them positionally would attach real
+ * people to the wrong profiles. So the parties come from the URLs, which are
+ * real identifiers; the names ride along only when both lists are the same
+ * length, where the correspondence is unambiguous.
+ *
+ * **A quarter of the bodies are HTML, and none of it is stored.** Sponsored
+ * InMail and templated LinkedIn notices arrive as the message editor's raw
+ * markup. `htmlToText` turns each back into the text a reader saw — keeping a
+ * link's URL as well as its label, since these anchors mostly say "here" — so
+ * a `Message` body is what was said and not how it was styled.
+ *
+ * **Attachments do not survive the export.** The `ATTACHMENTS` column holds
+ * signed `linkedin.com/dms/…` URLs that carry an expiry and a per-export token:
+ * the link dies long before the archive is old, and an entity keyed on it would
+ * mint a fresh identity every time you export. The bytes themselves are not in
+ * the ZIP. `hasAttachment` therefore rides the record for a future pass to use,
+ * and the transformer writes nothing for it — better a gap than a dead link
+ * dressed as a file.
+ */
+export declare class LinkedInArchiveMessagesExtractor extends LinkedInArchiveExtractor<typeof LinkedInArchiveMessagesExtractor> {
+    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=LinkedInArchiveMessagesExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchiveMessagesExtractor.js

@@ -0,0 +1,106 @@
+import { htmlToText } from '@chronicle.app/etl';
+import { memberName, parseSpaceStamp, profileHandle, profileUrl } from '../fields.js';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `messages.csv` — every LinkedIn message, newest-first, grouped by the
+ * conversation id LinkedIn assigns.
+ *
+ * **Names and profile URLs cannot be zipped together.** A group thread lists
+ * every participant's name in `TO` but only publishes URLs for the ones you may
+ * see, so the two comma-separated lists routinely differ in length and the
+ * n-th name is not the n-th URL. Pairing them positionally would attach real
+ * people to the wrong profiles. So the parties come from the URLs, which are
+ * real identifiers; the names ride along only when both lists are the same
+ * length, where the correspondence is unambiguous.
+ *
+ * **A quarter of the bodies are HTML, and none of it is stored.** Sponsored
+ * InMail and templated LinkedIn notices arrive as the message editor's raw
+ * markup. `htmlToText` turns each back into the text a reader saw — keeping a
+ * link's URL as well as its label, since these anchors mostly say "here" — so
+ * a `Message` body is what was said and not how it was styled.
+ *
+ * **Attachments do not survive the export.** The `ATTACHMENTS` column holds
+ * signed `linkedin.com/dms/…` URLs that carry an expiry and a per-export token:
+ * the link dies long before the archive is old, and an entity keyed on it would
+ * mint a fresh identity every time you export. The bytes themselves are not in
+ * the ZIP. `hasAttachment` therefore rides the record for a future pass to use,
+ * and the transformer writes nothing for it — better a gap than a dead link
+ * dressed as a file.
+ */
+export class LinkedInArchiveMessagesExtractor extends LinkedInArchiveExtractor {
+    static description = 'Messages';
+    static recordTypes = ['messages'];
+    static defaultTransformer = LinkedInTransformer;
+    static schema = LinkedInArchiveExtractor.schema;
+    async *extract() {
+        const rows = await this.readCsv('messages.csv');
+        const messages = rows
+            .map(row => {
+            const senderHandle = profileHandle(row['SENDER PROFILE URL']);
+            const senderName = memberName(row.FROM);
+            return {
+                conversationId: row['CONVERSATION ID']?.trim() || undefined,
+                conversationTitle: row['CONVERSATION TITLE']?.trim() || undefined,
+                sender: party(senderHandle, senderName),
+                recipients: parties(row.TO, row['RECIPIENT PROFILE URLS']),
+                subject: htmlToText(row.SUBJECT),
+                content: htmlToText(row.CONTENT),
+                folder: row.FOLDER?.trim() || undefined,
+                hasAttachment: Boolean(row.ATTACHMENTS?.trim()),
+                sentAt: parseSpaceStamp(row.DATE),
+            };
+        })
+            // The conversation and the moment are what make a message findable again;
+            // a row missing either is not a message we can place.
+            .filter(message => message.conversationId && message.sentAt)
+            .sort((a, b) => ((a.sentAt ?? '') < (b.sentAt ?? '') ? 1 : -1));
+        let count = 0;
+        for (const message of messages) {
+            if (this.shouldStopExtracting(count))
+                break;
+            if (!this.withinWindow(message.sentAt))
+                continue;
+            yield this.createRecordWithArchiveContext({
+                ...message,
+                occurredAt: message.sentAt,
+            });
+            count++;
+        }
+    }
+    async determineCount() {
+        return (await this.readCsv('messages.csv')).length;
+    }
+}
+/** One party, or nothing when LinkedIn identified them neither way. */
+function party(handle, name) {
+    if (!handle && !name)
+        return undefined;
+    return {
+        ...(handle && { handle, url: profileUrl(handle) }),
+        ...(name && { name }),
+    };
+}
+/**
+ * The recipients of one message. Handles come from the URL list; names are
+ * attached only when the two lists line up one-for-one (see the class note).
+ */
+function parties(rawNames, rawUrls) {
+    const names = splitList(rawNames).map(name => memberName(name));
+    const handles = splitList(rawUrls).flatMap(url => profileHandle(url) ?? []);
+    if (handles.length === 0) {
+        return names.flatMap(name => (name ? [{ name }] : []));
+    }
+    const aligned = names.length === handles.length;
+    return handles.map((handle, index) => ({
+        handle,
+        url: profileUrl(handle),
+        ...(aligned && names[index] && { name: names[index] }),
+    }));
+}
+function splitList(raw) {
+    return (raw ?? '')
+        .split(',')
+        .map(part => part.trim())
+        .filter(Boolean);
+}

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

@@ -0,0 +1,40 @@
+import { Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Positions.csv` — the work history, newest-first.
+ *
+ * `snapshot`, even though every row carries real dates. The dates ride the
+ * boundary actions and stay exactly where LinkedIn put them; what re-reads is
+ * the mutable part — a title, a description someone rewrote — and that belongs
+ * at the moment it was seen.
+ */
+export declare class LinkedInArchivePositionsExtractor extends LinkedInArchiveExtractor<typeof LinkedInArchivePositionsExtractor> {
+    static description: string;
+    static recordTypes: string[];
+    static temporality: "snapshot";
+    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=LinkedInArchivePositionsExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchivePositionsExtractor.js

@@ -0,0 +1,47 @@
+import { parseCoarseDate } from '../fields.js';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Positions.csv` — the work history, newest-first.
+ *
+ * `snapshot`, even though every row carries real dates. The dates ride the
+ * boundary actions and stay exactly where LinkedIn put them; what re-reads is
+ * the mutable part — a title, a description someone rewrote — and that belongs
+ * at the moment it was seen.
+ */
+export class LinkedInArchivePositionsExtractor extends LinkedInArchiveExtractor {
+    static description = 'Work history';
+    static recordTypes = ['positions'];
+    static temporality = 'snapshot';
+    static defaultTransformer = LinkedInTransformer;
+    static schema = LinkedInArchiveExtractor.schema;
+    async *extract() {
+        const rows = await this.readCsv('Positions.csv');
+        const positions = rows
+            .map(row => ({
+            company: row['Company Name']?.trim(),
+            title: row.Title?.trim(),
+            description: row.Description?.trim(),
+            location: row.Location?.trim(),
+            startedOn: parseCoarseDate(row['Started On']),
+            finishedOn: parseCoarseDate(row['Finished On']),
+        }))
+            .filter(position => position.company && position.startedOn)
+            .sort((a, b) => (a.startedOn < b.startedOn ? 1 : -1));
+        let count = 0;
+        for (const position of positions) {
+            if (this.shouldStopExtracting(count))
+                break;
+            if (!this.withinWindow(position.startedOn))
+                continue;
+            yield this.createRecordWithArchiveContext({
+                ...position,
+                occurredAt: position.startedOn,
+            });
+            count++;
+        }
+    }
+    async determineCount() {
+        return (await this.readCsv('Positions.csv')).length;
+    }
+}

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

@@ -0,0 +1,41 @@
+import { Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * The member themself: name, headline, location, and the primary email — one
+ * record, assembled from `Profile.csv` and `Email Addresses.csv` by the base
+ * class's account read.
+ *
+ * A re-read of current state, so `snapshot`: a headline changes, and the change
+ * belongs at the moment we saw it rather than back-dated to whenever the
+ * account was created.
+ */
+export declare class LinkedInArchiveProfileExtractor extends LinkedInArchiveExtractor<typeof LinkedInArchiveProfileExtractor> {
+    static description: string;
+    static recordTypes: string[];
+    static temporality: "snapshot";
+    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=LinkedInArchiveProfileExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchiveProfileExtractor.js

@@ -0,0 +1,27 @@
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * The member themself: name, headline, location, and the primary email — one
+ * record, assembled from `Profile.csv` and `Email Addresses.csv` by the base
+ * class's account read.
+ *
+ * A re-read of current state, so `snapshot`: a headline changes, and the change
+ * belongs at the moment we saw it rather than back-dated to whenever the
+ * account was created.
+ */
+export class LinkedInArchiveProfileExtractor extends LinkedInArchiveExtractor {
+    static description = 'Profile: name, headline, location, email';
+    static recordTypes = ['profile'];
+    static temporality = 'snapshot';
+    static defaultTransformer = LinkedInTransformer;
+    static schema = LinkedInArchiveExtractor.schema;
+    async *extract() {
+        const account = this.accountInfo;
+        if (!account.name && !account.handle && !account.email)
+            return;
+        yield this.createRecordWithArchiveContext({ ...account });
+    }
+    async determineCount() {
+        return 1;
+    }
+}

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

@@ -0,0 +1,30 @@
+import { MergingExtractor, Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveMessagesExtractor } from './LinkedInArchiveMessagesExtractor.js';
+/**
+ * The whole export in one reverse-chronological pass — what a bare
+ * `extract linkedin -i <dir>` means.
+ *
+ * Every file is included rather than a curated subset: a LinkedIn export is
+ * small enough to read end to end, and each of its files is the only copy of
+ * what it holds. The profile record has no date and so lands last; everything
+ * else interleaves by when it actually happened.
+ */
+export declare class LinkedInDefaultExtractor extends MergingExtractor<typeof LinkedInDefaultExtractor> {
+    static source: string;
+    static description: string;
+    static delivery: "export";
+    static strategy: string;
+    static recordTypes: string[];
+    static default: boolean;
+    static defaultTransformer: typeof LinkedInTransformer;
+    static children: (typeof LinkedInArchiveMessagesExtractor)[];
+    static schema: any;
+    /**
+     * Every child dates its records the same way, on `occurredAt`. A record with
+     * no date at all (the profile) sorts to the end rather than to 1970 by
+     * accident — the merge is newest-first, and undated is not "oldest".
+     */
+    protected sortKey(record: Record): number;
+}
+//# sourceMappingURL=LinkedInDefaultExtractor.d.ts.map

package/dist/connectors/archive/LinkedInDefaultExtractor.js

@@ -0,0 +1,69 @@
+import { MergingExtractor } from '@chronicle.app/etl';
+import { z } from 'zod';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveConnectionsExtractor } from './LinkedInArchiveConnectionsExtractor.js';
+import { LinkedInArchiveEducationExtractor } from './LinkedInArchiveEducationExtractor.js';
+import { LinkedInArchiveEndorsementsExtractor } from './LinkedInArchiveEndorsementsExtractor.js';
+import { LinkedInArchiveFollowsExtractor } from './LinkedInArchiveFollowsExtractor.js';
+import { LinkedInArchiveLearningExtractor } from './LinkedInArchiveLearningExtractor.js';
+import { LinkedInArchiveMessagesExtractor } from './LinkedInArchiveMessagesExtractor.js';
+import { LinkedInArchivePositionsExtractor } from './LinkedInArchivePositionsExtractor.js';
+import { LinkedInArchiveProfileExtractor } from './LinkedInArchiveProfileExtractor.js';
+/**
+ * The whole export in one reverse-chronological pass — what a bare
+ * `extract linkedin -i <dir>` means.
+ *
+ * Every file is included rather than a curated subset: a LinkedIn export is
+ * small enough to read end to end, and each of its files is the only copy of
+ * what it holds. The profile record has no date and so lands last; everything
+ * else interleaves by when it actually happened.
+ */
+export class LinkedInDefaultExtractor extends MergingExtractor {
+    static source = 'linkedin';
+    static description = 'Everything in the export, newest first';
+    static delivery = 'export';
+    static strategy = 'archive';
+    static recordTypes = [
+        'messages',
+        'connections',
+        'endorsements',
+        'follows',
+        'positions',
+        'education',
+        'learning',
+        'profile',
+    ];
+    static default = true;
+    static defaultTransformer = LinkedInTransformer;
+    static children = [
+        LinkedInArchiveMessagesExtractor,
+        LinkedInArchiveConnectionsExtractor,
+        LinkedInArchiveEndorsementsExtractor,
+        LinkedInArchiveFollowsExtractor,
+        LinkedInArchivePositionsExtractor,
+        LinkedInArchiveEducationExtractor,
+        LinkedInArchiveLearningExtractor,
+        LinkedInArchiveProfileExtractor,
+    ];
+    // The union of the children's flags, so the runner forwards them to the merge
+    // and the merge forwards the raw config to each child.
+    static schema = MergingExtractor.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.'),
+    });
+    /**
+     * Every child dates its records the same way, on `occurredAt`. A record with
+     * no date at all (the profile) sorts to the end rather than to 1970 by
+     * accident — the merge is newest-first, and undated is not "oldest".
+     */
+    sortKey(record) {
+        const { occurredAt } = record.data;
+        if (!occurredAt)
+            return Number.NEGATIVE_INFINITY;
+        const parsed = Date.parse(occurredAt);
+        return Number.isNaN(parsed) ? Number.NEGATIVE_INFINITY : parsed;
+    }
+}

package/dist/connectors/fields.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Field readers shared by the extractors: the identity hiding in a LinkedIn
+ * profile URL, and the seven date formats one export manages to use.
+ *
+ * Everything here returns what LinkedIn actually wrote, at the precision it
+ * wrote it. Nothing invents a value it was not given — a date the source knows
+ * only to the month stays a month, and an unparseable one comes back undefined
+ * rather than as a guess.
+ */
+/**
+ * The vanity slug out of a member profile URL — LinkedIn's own public handle
+ * for a person, and the only identifier the CSVs carry for anyone but you.
+ *
+ * The export writes the URL three ways: with a scheme (`Connections.csv`),
+ * without one (`Endorsement_*.csv`), and with tracking params glued on when the
+ * member pasted it out of the mobile app. All three name the same slug.
+ *
+ * **The slug is not stable.** A member can change their vanity URL, and when
+ * they do a later export calls them someone new. It is still the best
+ * identifier LinkedIn gives us — the numeric member id never appears in an
+ * export — so it is what we key on, with the weakness recorded here.
+ */
+export declare function profileHandle(rawUrl: string | undefined): string | undefined;
+/** The canonical public profile URL for a slug, however the export spelled it. */
+export declare function profileUrl(handle: string): string;
+/**
+ * A display name, or nothing when the export withheld one.
+ *
+ * The private-member placeholder is treated as absent rather than as a name.
+ * Keying people on it would collapse every stranger LinkedIn hid from you into
+ * a single person who does not exist.
+ */
+export declare function memberName(raw: string | undefined): string | undefined;
+/**
+ * `2026-08-05 19:29:58 UTC` (messages) and `2020-12-29 14:24 UTC` (learning) —
+ * an ISO-ish stamp with a trailing zone word instead of an offset.
+ */
+export declare function parseSpaceStamp(raw: string | undefined): string | undefined;
+/** `2017/05/07 01:01:57 UTC` — the endorsement files' slash-dated stamp. */
+export declare function parseSlashStamp(raw: string | undefined): string | undefined;
+/** `Fri Jan 24 02:54:41 UTC 2025` — the follow files' `Date.toString()` shape. */
+export declare function parseLongStamp(raw: string | undefined): string | undefined;
+/**
+ * `06 Jun 2026` — a connection date. LinkedIn records the day, not the moment,
+ * so this stays a day-precision civil date rather than being widened to
+ * midnight UTC.
+ */
+export declare function parseDayDate(raw: string | undefined): string | undefined;
+/**
+ * `Aug 2022`, or a bare `2009` — a position or education boundary. LinkedIn
+ * only ever asks for the month, and for older entries only the year, so the
+ * result carries that precision: `2022-08` and `2009`. The store parses each at
+ * its own precision, which is why widening them to a day would be a lie.
+ */
+export declare function parseCoarseDate(raw: string | undefined): string | undefined;
+//# sourceMappingURL=fields.d.ts.map

package/dist/connectors/fields.js

@@ -0,0 +1,129 @@
+/**
+ * Field readers shared by the extractors: the identity hiding in a LinkedIn
+ * profile URL, and the seven date formats one export manages to use.
+ *
+ * Everything here returns what LinkedIn actually wrote, at the precision it
+ * wrote it. Nothing invents a value it was not given — a date the source knows
+ * only to the month stays a month, and an unparseable one comes back undefined
+ * rather than as a guess.
+ */
+/**
+ * The vanity slug out of a member profile URL — LinkedIn's own public handle
+ * for a person, and the only identifier the CSVs carry for anyone but you.
+ *
+ * The export writes the URL three ways: with a scheme (`Connections.csv`),
+ * without one (`Endorsement_*.csv`), and with tracking params glued on when the
+ * member pasted it out of the mobile app. All three name the same slug.
+ *
+ * **The slug is not stable.** A member can change their vanity URL, and when
+ * they do a later export calls them someone new. It is still the best
+ * identifier LinkedIn gives us — the numeric member id never appears in an
+ * export — so it is what we key on, with the weakness recorded here.
+ */
+export function profileHandle(rawUrl) {
+    const url = rawUrl?.trim();
+    if (!url)
+        return undefined;
+    const match = /\/in\/([^/?#\s]+)/.exec(url);
+    const slug = match?.[1]?.trim();
+    return slug ? decodeURIComponent(slug) : undefined;
+}
+/** The canonical public profile URL for a slug, however the export spelled it. */
+export function profileUrl(handle) {
+    return `https://www.linkedin.com/in/${handle}`;
+}
+/**
+ * What LinkedIn prints instead of a name for a member you are not allowed to
+ * see. It appears across the export — as a message sender, as a recipient —
+ * and it is a placeholder, not a name.
+ */
+const PRIVATE_MEMBER = 'LinkedIn Member';
+/**
+ * A display name, or nothing when the export withheld one.
+ *
+ * The private-member placeholder is treated as absent rather than as a name.
+ * Keying people on it would collapse every stranger LinkedIn hid from you into
+ * a single person who does not exist.
+ */
+export function memberName(raw) {
+    const name = raw?.trim();
+    return !name || name === PRIVATE_MEMBER ? undefined : name;
+}
+/**
+ * `2026-08-05 19:29:58 UTC` (messages) and `2020-12-29 14:24 UTC` (learning) —
+ * an ISO-ish stamp with a trailing zone word instead of an offset.
+ */
+export function parseSpaceStamp(raw) {
+    const value = raw?.trim();
+    if (!value || value === 'N/A')
+        return undefined;
+    const iso = value.replace(' UTC', 'Z').replace(' ', 'T');
+    return isoOrUndefined(iso);
+}
+/** `2017/05/07 01:01:57 UTC` — the endorsement files' slash-dated stamp. */
+export function parseSlashStamp(raw) {
+    const value = raw?.trim();
+    if (!value)
+        return undefined;
+    const iso = value.replaceAll('/', '-').replace(' UTC', 'Z').replace(' ', 'T');
+    return isoOrUndefined(iso);
+}
+/** `Fri Jan 24 02:54:41 UTC 2025` — the follow files' `Date.toString()` shape. */
+export function parseLongStamp(raw) {
+    return isoOrUndefined(raw?.trim());
+}
+/**
+ * `06 Jun 2026` — a connection date. LinkedIn records the day, not the moment,
+ * so this stays a day-precision civil date rather than being widened to
+ * midnight UTC.
+ */
+export function parseDayDate(raw) {
+    const value = raw?.trim();
+    if (!value)
+        return undefined;
+    const match = /^(\d{1,2})\s+([A-Za-z]{3,})\s+(\d{4})$/.exec(value);
+    if (!match)
+        return undefined;
+    const month = MONTHS[match[2].slice(0, 3).toLowerCase()];
+    if (!month)
+        return undefined;
+    return `${match[3]}-${month}-${match[1].padStart(2, '0')}`;
+}
+/**
+ * `Aug 2022`, or a bare `2009` — a position or education boundary. LinkedIn
+ * only ever asks for the month, and for older entries only the year, so the
+ * result carries that precision: `2022-08` and `2009`. The store parses each at
+ * its own precision, which is why widening them to a day would be a lie.
+ */
+export function parseCoarseDate(raw) {
+    const value = raw?.trim();
+    if (!value)
+        return undefined;
+    if (/^\d{4}$/.test(value))
+        return value;
+    const match = /^([A-Za-z]{3,})\s+(\d{4})$/.exec(value);
+    if (!match)
+        return undefined;
+    const month = MONTHS[match[1].slice(0, 3).toLowerCase()];
+    return month ? `${match[2]}-${month}` : undefined;
+}
+const MONTHS = {
+    jan: '01',
+    feb: '02',
+    mar: '03',
+    apr: '04',
+    may: '05',
+    jun: '06',
+    jul: '07',
+    aug: '08',
+    sep: '09',
+    oct: '10',
+    nov: '11',
+    dec: '12',
+};
+function isoOrUndefined(value) {
+    if (!value)
+        return undefined;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { LinkedInArchiveExtractor } from './connectors/archive/LinkedInArchiveExtractor.js';
+export { LinkedInArchiveConnectionsExtractor } from './connectors/archive/LinkedInArchiveConnectionsExtractor.js';
+export { LinkedInArchiveEducationExtractor } from './connectors/archive/LinkedInArchiveEducationExtractor.js';
+export { LinkedInArchiveEndorsementsExtractor } from './connectors/archive/LinkedInArchiveEndorsementsExtractor.js';
+export { LinkedInArchiveFollowsExtractor } from './connectors/archive/LinkedInArchiveFollowsExtractor.js';
+export { LinkedInArchiveLearningExtractor } from './connectors/archive/LinkedInArchiveLearningExtractor.js';
+export { LinkedInArchiveMessagesExtractor } from './connectors/archive/LinkedInArchiveMessagesExtractor.js';
+export { LinkedInArchivePositionsExtractor } from './connectors/archive/LinkedInArchivePositionsExtractor.js';
+export { LinkedInArchiveProfileExtractor } from './connectors/archive/LinkedInArchiveProfileExtractor.js';
+export { LinkedInDefaultExtractor } from './connectors/archive/LinkedInDefaultExtractor.js';
+export { default as LinkedInTransformer } from './connectors/LinkedInTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,11 @@
+export { LinkedInArchiveExtractor } from './connectors/archive/LinkedInArchiveExtractor.js';
+export { LinkedInArchiveConnectionsExtractor } from './connectors/archive/LinkedInArchiveConnectionsExtractor.js';
+export { LinkedInArchiveEducationExtractor } from './connectors/archive/LinkedInArchiveEducationExtractor.js';
+export { LinkedInArchiveEndorsementsExtractor } from './connectors/archive/LinkedInArchiveEndorsementsExtractor.js';
+export { LinkedInArchiveFollowsExtractor } from './connectors/archive/LinkedInArchiveFollowsExtractor.js';
+export { LinkedInArchiveLearningExtractor } from './connectors/archive/LinkedInArchiveLearningExtractor.js';
+export { LinkedInArchiveMessagesExtractor } from './connectors/archive/LinkedInArchiveMessagesExtractor.js';
+export { LinkedInArchivePositionsExtractor } from './connectors/archive/LinkedInArchivePositionsExtractor.js';
+export { LinkedInArchiveProfileExtractor } from './connectors/archive/LinkedInArchiveProfileExtractor.js';
+export { LinkedInDefaultExtractor } from './connectors/archive/LinkedInDefaultExtractor.js';
+export { default as LinkedInTransformer } from './connectors/LinkedInTransformer.js';