@destink/substack-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,929 @@
+'use strict';
+
+var initCycleTLS = require('cycletls');
+var t = require('io-ts');
+var _function = require('fp-ts/function');
+var Either = require('fp-ts/Either');
+var PathReporter = require('io-ts/PathReporter');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var t__namespace = /*#__PURE__*/_interopNamespaceDefault(t);
+
+/**
+ * HTTP client for direct Substack API access via CycleTLS
+ *
+ * Uses CycleTLS to bypass Cloudflare bot detection by spoofing browser
+ * TLS/JA3 fingerprints. Authentication is via session cookies sent directly
+ * to Substack — no third-party proxy involved.
+ */
+const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+class HttpClient {
+    constructor(config) {
+        this.client = null;
+        this.lastRequestTime = 0;
+        this.headers = {
+            'Content-Type': 'application/json',
+            Cookie: `substack.sid=${config.substackSid}; substack.lli=${config.substackLli}`
+        };
+        this.publicationBaseUrl = config.publicationUrl.replace(/\/$/, '');
+        this.minInterval = 1000 / (config.maxRequestsPerSecond || 25);
+    }
+    async getClient() {
+        if (!this.client) {
+            this.client = await initCycleTLS();
+        }
+        return this.client;
+    }
+    async throttle() {
+        const now = Date.now();
+        const elapsed = now - this.lastRequestTime;
+        if (elapsed < this.minInterval) {
+            await new Promise((r) => setTimeout(r, this.minInterval - elapsed));
+        }
+        this.lastRequestTime = Date.now();
+    }
+    resolveBaseUrl(scope) {
+        if (scope === 'global')
+            return 'https://substack.com';
+        if (scope === 'publication')
+            return this.publicationBaseUrl;
+        return `https://${scope.subdomain}.substack.com`;
+    }
+    buildUrl(path, scope, params) {
+        const base = this.resolveBaseUrl(scope);
+        let url = `${base}${path}`;
+        if (params) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined) {
+                    searchParams.set(key, String(value));
+                }
+            }
+            const qs = searchParams.toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        return url;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    parseResponseData(data) {
+        if (typeof data === 'string') {
+            try {
+                return JSON.parse(data);
+            }
+            catch (_a) {
+                return data;
+            }
+        }
+        return data;
+    }
+    async get(path, params, scope = 'global') {
+        await this.throttle();
+        const url = this.buildUrl(path, scope, params);
+        const client = await this.getClient();
+        const response = await client(url, { headers: this.headers, userAgent: USER_AGENT }, 'get');
+        if (response.status === 401 || response.status === 403) {
+            throw new Error(`Authentication failed (${response.status}). Your session cookies may have expired.`);
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`HTTP ${response.status} for GET ${path}`);
+        }
+        return this.parseResponseData(response.data);
+    }
+    async post(path, data, scope = 'global') {
+        await this.throttle();
+        const url = this.buildUrl(path, scope);
+        const client = await this.getClient();
+        const response = await client(url, {
+            headers: this.headers,
+            userAgent: USER_AGENT,
+            ...(data !== undefined ? { body: JSON.stringify(data) } : {})
+        }, 'post');
+        if (response.status === 401 || response.status === 403) {
+            throw new Error(`Authentication failed (${response.status}). Your session cookies may have expired.`);
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`HTTP ${response.status} for POST ${path}`);
+        }
+        return this.parseResponseData(response.data);
+    }
+    async put(path, data, scope = 'global') {
+        await this.throttle();
+        const url = this.buildUrl(path, scope);
+        const client = await this.getClient();
+        const response = await client(url, {
+            headers: this.headers,
+            userAgent: USER_AGENT,
+            ...(data !== undefined ? { body: JSON.stringify(data) } : {})
+        }, 'put');
+        if (response.status === 401 || response.status === 403) {
+            throw new Error(`Authentication failed (${response.status}). Your session cookies may have expired.`);
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`HTTP ${response.status} for PUT ${path}`);
+        }
+        return this.parseResponseData(response.data);
+    }
+    async delete(path, scope = 'global') {
+        await this.throttle();
+        const url = this.buildUrl(path, scope);
+        const client = await this.getClient();
+        const response = await client(url, { headers: this.headers, userAgent: USER_AGENT }, 'delete');
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`HTTP ${response.status} for DELETE ${path}`);
+        }
+    }
+    async close() {
+        if (this.client) {
+            await this.client.exit();
+            this.client = null;
+        }
+    }
+}
+
+class Comment {
+    constructor(rawData) {
+        var _a, _b;
+        this.rawData = rawData;
+        this.id = rawData.id;
+        this.body = rawData.body;
+        this.date = rawData.date;
+        this.authorName = (_a = rawData.name) !== null && _a !== void 0 ? _a : undefined;
+        this.authorHandle = (_b = rawData.handle) !== null && _b !== void 0 ? _b : undefined;
+        this.reactionCount = rawData.reaction_count;
+    }
+}
+
+class PreviewPost {
+    constructor(rawData, commentService, postService, publicationSubdomain) {
+        this.commentService = commentService;
+        this.postService = postService;
+        this.id = rawData.id;
+        this.title = rawData.title;
+        this.slug = rawData.slug;
+        this.subtitle = rawData.subtitle || '';
+        this.truncatedBody = rawData.truncated_body_text || '';
+        this.body = rawData.body_html || rawData.truncated_body_text || '';
+        this.publishedAt = new Date(rawData.post_date);
+        this.publicationSubdomain = publicationSubdomain;
+    }
+    async fullPost() {
+        try {
+            const fullPostData = await this.postService.getPostBySlug(this.slug, this.publicationSubdomain);
+            return new FullPost(fullPostData, this.commentService, this.publicationSubdomain);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch full post ${this.slug}: ${error.message}`);
+        }
+    }
+    async *comments(options = {}) {
+        try {
+            const commentsData = await this.commentService.getCommentsForPost(this.id, this.publicationSubdomain);
+            let count = 0;
+            for (const commentData of commentsData) {
+                if (options.limit && count >= options.limit)
+                    break;
+                yield new Comment(commentData);
+                count++;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to get comments for post ${this.id}: ${error.message}`);
+        }
+    }
+    async like() {
+        throw new Error('Post liking not implemented yet - requires like API');
+    }
+    async addComment(_data) {
+        throw new Error('Comment creation not implemented yet - requires comment creation API');
+    }
+}
+class FullPost {
+    constructor(rawData, commentService, publicationSubdomain) {
+        var _a, _b, _c;
+        this.commentService = commentService;
+        this.publicationSubdomain = publicationSubdomain;
+        this.id = rawData.id;
+        this.title = rawData.title;
+        this.subtitle = rawData.subtitle || '';
+        this.truncatedBody = rawData.truncated_body_text || '';
+        this.body = rawData.body_html || rawData.truncated_body_text || '';
+        this.publishedAt = new Date(rawData.post_date);
+        this.url = rawData.canonical_url || '';
+        this.htmlBody = rawData.body_html || '';
+        this.slug = rawData.slug;
+        this.createdAt = new Date(rawData.post_date);
+        this.reactions = (_a = rawData.reactions) !== null && _a !== void 0 ? _a : undefined;
+        this.restacks = (_b = rawData.restacks) !== null && _b !== void 0 ? _b : undefined;
+        this.coverImage = (_c = rawData.cover_image) !== null && _c !== void 0 ? _c : undefined;
+    }
+    async *comments(options = {}) {
+        try {
+            const commentsData = await this.commentService.getCommentsForPost(this.id, this.publicationSubdomain);
+            let count = 0;
+            for (const commentData of commentsData) {
+                if (options.limit && count >= options.limit)
+                    break;
+                yield new Comment(commentData);
+                count++;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to get comments for post ${this.id}: ${error.message}`);
+        }
+    }
+    async like() {
+        throw new Error('Post liking not implemented yet - requires like API');
+    }
+    async addComment(_data) {
+        throw new Error('Comment creation not implemented yet - requires comment creation API');
+    }
+}
+
+class Note {
+    constructor(rawData) {
+        var _a;
+        this.rawData = rawData;
+        this.id = rawData.id;
+        this.body = rawData.body;
+        this.likesCount = (_a = rawData.reaction_count) !== null && _a !== void 0 ? _a : 0;
+        this.publishedAt = new Date(rawData.date);
+        this.author = {
+            id: rawData.user_id,
+            name: rawData.name || '',
+            handle: rawData.handle || '',
+            avatarUrl: rawData.photo_url || ''
+        };
+    }
+}
+
+class Profile {
+    constructor(rawData, postService, noteService, commentService, perPage) {
+        var _a;
+        this.rawData = rawData;
+        this.postService = postService;
+        this.noteService = noteService;
+        this.commentService = commentService;
+        this.perPage = perPage;
+        this.id = rawData.id;
+        this.slug = rawData.handle;
+        this.handle = rawData.handle;
+        this.name = rawData.name;
+        this.url = `https://substack.com/@${rawData.handle}`;
+        this.avatarUrl = rawData.photo_url;
+        this.bio = (_a = rawData.bio) !== null && _a !== void 0 ? _a : undefined;
+    }
+    async *posts(options = {}) {
+        var _a;
+        try {
+            let cursor = undefined;
+            let totalYielded = 0;
+            while (true) {
+                const result = await this.postService.getPostsForProfile(this.id, { cursor });
+                for (const feedItem of result.posts) {
+                    if (options.limit && totalYielded >= options.limit) {
+                        return;
+                    }
+                    if (feedItem.post) {
+                        const subdomain = (_a = feedItem.publication) === null || _a === void 0 ? void 0 : _a.subdomain;
+                        yield new PreviewPost(feedItem.post, this.commentService, this.postService, subdomain);
+                        totalYielded++;
+                    }
+                }
+                if (!result.nextCursor || result.posts.length === 0) {
+                    break;
+                }
+                cursor = result.nextCursor;
+            }
+        }
+        catch (_b) {
+            yield* [];
+        }
+    }
+    async *notes(options = {}) {
+        try {
+            let cursor = undefined;
+            let totalYielded = 0;
+            while (true) {
+                const paginatedNotes = await this.noteService.getNotesForProfile(this.id, { cursor });
+                for (const item of paginatedNotes.notes) {
+                    if (options.limit && totalYielded >= options.limit) {
+                        return;
+                    }
+                    yield new Note(item);
+                    totalYielded++;
+                }
+                if (!paginatedNotes.nextCursor) {
+                    break;
+                }
+                cursor = paginatedNotes.nextCursor;
+            }
+        }
+        catch (_a) {
+            yield* [];
+        }
+    }
+}
+
+class OwnProfile extends Profile {
+    constructor(rawData, postService, noteService, commentService, profileService, followingService, newNoteService, perPage) {
+        super(rawData, postService, noteService, commentService, perPage);
+        this.profileService = profileService;
+        this.followingService = followingService;
+        this.newNoteService = newNoteService;
+    }
+    async publishNote(content, options) {
+        return this.newNoteService.publishNote(content, options === null || options === void 0 ? void 0 : options.attachmentIds);
+    }
+    async *following(options = {}) {
+        const followingUsers = await this.followingService.getFollowing();
+        let count = 0;
+        for (const user of followingUsers) {
+            if (options.limit && count >= options.limit)
+                break;
+            try {
+                const profileData = await this.profileService.getProfileBySlug(user.handle);
+                yield new Profile(profileData, this.postService, this.noteService, this.commentService, this.perPage);
+                count++;
+            }
+            catch (_a) {
+                /* empty */
+            }
+        }
+    }
+    async *notes(options = {}) {
+        try {
+            let cursor = undefined;
+            let totalYielded = 0;
+            while (true) {
+                const paginatedNotes = await this.noteService.getNotesForProfile(this.id, { cursor });
+                for (const noteData of paginatedNotes.notes) {
+                    if (options.limit && totalYielded >= options.limit) {
+                        return;
+                    }
+                    yield new Note(noteData);
+                    totalYielded++;
+                }
+                if (!paginatedNotes.nextCursor) {
+                    break;
+                }
+                cursor = paginatedNotes.nextCursor;
+            }
+        }
+        catch (_a) {
+            yield* [];
+        }
+    }
+}
+
+/**
+ * io-ts codecs and inferred types for Substack API response shapes.
+ *
+ * These match the real Substack API responses (not the gateway proxy).
+ * Fields are validated loosely — only the fields used by domain entities
+ * are required; extra fields from Substack are ignored by io-ts.
+ */
+// ------------------------------------------------------------------
+// Profile
+// ------------------------------------------------------------------
+const SubstackProfileC = t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        handle: t__namespace.string,
+        name: t__namespace.string,
+        photo_url: t__namespace.string
+    }),
+    t__namespace.partial({
+        bio: t__namespace.union([t__namespace.string, t__namespace.null])
+    })
+]);
+// ------------------------------------------------------------------
+// Feed envelope (shared by posts, notes, following feeds)
+// ------------------------------------------------------------------
+const SubstackFeedItemPostC = t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        title: t__namespace.string,
+        slug: t__namespace.string,
+        post_date: t__namespace.string
+    }),
+    t__namespace.partial({
+        subtitle: t__namespace.union([t__namespace.string, t__namespace.null]),
+        truncated_body_text: t__namespace.union([t__namespace.string, t__namespace.null]),
+        body_html: t__namespace.union([t__namespace.string, t__namespace.null]),
+        canonical_url: t__namespace.union([t__namespace.string, t__namespace.null]),
+        reactions: t__namespace.union([t__namespace.record(t__namespace.string, t__namespace.number), t__namespace.null]),
+        restacks: t__namespace.union([t__namespace.number, t__namespace.null]),
+        cover_image: t__namespace.union([t__namespace.string, t__namespace.null]),
+        publication_id: t__namespace.number,
+        comment_count: t__namespace.number,
+        type: t__namespace.string
+    })
+]);
+const SubstackFeedPublicationC = t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        subdomain: t__namespace.string,
+        name: t__namespace.string
+    }),
+    t__namespace.partial({
+        custom_domain: t__namespace.union([t__namespace.string, t__namespace.null]),
+        logo_url: t__namespace.union([t__namespace.string, t__namespace.null]),
+        author_id: t__namespace.number
+    })
+]);
+const SubstackFeedCommentC = t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        body: t__namespace.string,
+        user_id: t__namespace.number,
+        date: t__namespace.string
+    }),
+    t__namespace.partial({
+        name: t__namespace.union([t__namespace.string, t__namespace.null]),
+        handle: t__namespace.union([t__namespace.string, t__namespace.null]),
+        photo_url: t__namespace.union([t__namespace.string, t__namespace.null]),
+        body_json: t__namespace.unknown,
+        publication_id: t__namespace.union([t__namespace.number, t__namespace.null]),
+        post_id: t__namespace.union([t__namespace.number, t__namespace.null]),
+        type: t__namespace.string,
+        reaction_count: t__namespace.number,
+        reactions: t__namespace.union([t__namespace.record(t__namespace.string, t__namespace.number), t__namespace.null]),
+        restacks: t__namespace.number,
+        children_count: t__namespace.number,
+        attachments: t__namespace.array(t__namespace.unknown),
+        ancestor_path: t__namespace.string,
+        edited_at: t__namespace.union([t__namespace.string, t__namespace.null]),
+        reply_minimum_role: t__namespace.union([t__namespace.string, t__namespace.null])
+    })
+]);
+const SubstackFeedItemC = t__namespace.intersection([
+    t__namespace.type({
+        entity_key: t__namespace.string,
+        type: t__namespace.string
+    }),
+    t__namespace.partial({
+        publication: t__namespace.union([SubstackFeedPublicationC, t__namespace.null]),
+        post: t__namespace.union([SubstackFeedItemPostC, t__namespace.null]),
+        comment: t__namespace.union([SubstackFeedCommentC, t__namespace.null])
+    })
+]);
+const SubstackFeedPageC = t__namespace.intersection([
+    t__namespace.type({
+        items: t__namespace.array(SubstackFeedItemC)
+    }),
+    t__namespace.partial({
+        nextCursor: t__namespace.union([t__namespace.string, t__namespace.null]),
+        originalCursorTimestamp: t__namespace.union([t__namespace.string, t__namespace.null])
+    })
+]);
+// ------------------------------------------------------------------
+// Full post (from GET /api/v1/posts/{slug})
+// ------------------------------------------------------------------
+const SubstackFullPostC = t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        title: t__namespace.string,
+        slug: t__namespace.string,
+        post_date: t__namespace.string
+    }),
+    t__namespace.partial({
+        subtitle: t__namespace.union([t__namespace.string, t__namespace.null]),
+        body_html: t__namespace.union([t__namespace.string, t__namespace.null]),
+        truncated_body_text: t__namespace.union([t__namespace.string, t__namespace.null]),
+        canonical_url: t__namespace.union([t__namespace.string, t__namespace.null]),
+        reactions: t__namespace.union([t__namespace.record(t__namespace.string, t__namespace.number), t__namespace.null]),
+        restacks: t__namespace.union([t__namespace.number, t__namespace.null]),
+        cover_image: t__namespace.union([t__namespace.string, t__namespace.null]),
+        publication_id: t__namespace.number,
+        type: t__namespace.string,
+        is_published: t__namespace.boolean,
+        comment_count: t__namespace.number
+    })
+]);
+// ------------------------------------------------------------------
+// Comments (from GET /api/v1/post/{id}/comments)
+// ------------------------------------------------------------------
+const SubstackCommentC = t__namespace.recursion('SubstackComment', () => t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        body: t__namespace.string
+    }),
+    t__namespace.partial({
+        body_json: t__namespace.unknown,
+        publication_id: t__namespace.union([t__namespace.number, t__namespace.null]),
+        post_id: t__namespace.union([t__namespace.number, t__namespace.null]),
+        user_id: t__namespace.number,
+        ancestor_path: t__namespace.string,
+        type: t__namespace.string,
+        date: t__namespace.string,
+        name: t__namespace.union([t__namespace.string, t__namespace.null]),
+        handle: t__namespace.union([t__namespace.string, t__namespace.null]),
+        photo_url: t__namespace.union([t__namespace.string, t__namespace.null]),
+        reaction_count: t__namespace.number,
+        reactions: t__namespace.union([t__namespace.record(t__namespace.string, t__namespace.number), t__namespace.null]),
+        restacks: t__namespace.number,
+        deleted: t__namespace.boolean,
+        children: t__namespace.array(SubstackCommentC)
+    })
+]));
+const SubstackCommentsResponseC = t__namespace.type({
+    comments: t__namespace.array(SubstackCommentC)
+});
+// ------------------------------------------------------------------
+// Subscriptions / Following (from GET /api/v1/subscriptions/page)
+// ------------------------------------------------------------------
+const SubscriptionPublicationAuthorC = t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        handle: t__namespace.string
+    }),
+    t__namespace.partial({
+        name: t__namespace.union([t__namespace.string, t__namespace.null]),
+        photo_url: t__namespace.union([t__namespace.string, t__namespace.null])
+    })
+]);
+const SubscriptionPublicationC = t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        subdomain: t__namespace.string,
+        name: t__namespace.string
+    }),
+    t__namespace.partial({
+        author: SubscriptionPublicationAuthorC
+    })
+]);
+const SubscriptionC = t__namespace.intersection([
+    t__namespace.type({
+        id: t__namespace.number,
+        publication_id: t__namespace.number
+    }),
+    t__namespace.partial({
+        membership_state: t__namespace.string,
+        publication: SubscriptionPublicationC
+    })
+]);
+const SubstackSubscriptionsResponseC = t__namespace.type({
+    subscriptions: t__namespace.array(SubscriptionC)
+});
+// ------------------------------------------------------------------
+// Create note response (from POST /api/v1/comment/feed)
+// ------------------------------------------------------------------
+const SubstackCreateNoteResponseC = t__namespace.type({ id: t__namespace.number });
+
+/**
+ * Utility functions for runtime validation using io-ts and fp-ts
+ */
+/**
+ * Decode and validate data using an io-ts codec
+ * @param codec - The io-ts codec to use for validation
+ * @param data - The raw data to validate
+ * @param errorContext - Context information for error messages
+ * @returns The validated data
+ * @throws {Error} If validation fails
+ */
+function decodeOrThrow(codec, data, errorContext) {
+    const result = codec.decode(data);
+    return _function.pipe(result, Either.fold((_errors) => {
+        const errorMessage = PathReporter.PathReporter.report(result).join(', ');
+        console.log(`Invalid ${errorContext}: ${errorMessage}`);
+        throw new Error(`Invalid ${errorContext}: ${errorMessage}`);
+    }, (parsed) => parsed));
+}
+
+class PostService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getPostBySlug(slug, subdomain) {
+        const scope = subdomain ? { subdomain } : 'publication';
+        const raw = await this.client.get(`/api/v1/posts/${encodeURIComponent(slug)}`, undefined, scope);
+        return decodeOrThrow(SubstackFullPostC, raw, 'SubstackFullPost');
+    }
+    async getPostsForProfile(userId, options) {
+        const params = {};
+        if (options === null || options === void 0 ? void 0 : options.cursor)
+            params.cursor = options.cursor;
+        const raw = await this.client.get(`/api/v1/reader/feed/profile/${userId}`, params);
+        const page = decodeOrThrow(SubstackFeedPageC, raw, 'SubstackFeedPage');
+        const postItems = page.items.filter((item) => item.type === 'post');
+        return { posts: postItems, nextCursor: page.nextCursor };
+    }
+}
+
+class NoteService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getNotesForProfile(userId, options) {
+        const params = { filter: 'comment' };
+        if (options === null || options === void 0 ? void 0 : options.cursor)
+            params.cursor = options.cursor;
+        const raw = await this.client.get(`/api/v1/reader/feed/profile/${userId}`, params);
+        const page = decodeOrThrow(SubstackFeedPageC, raw, 'SubstackFeedPage');
+        const notes = page.items
+            .filter((item) => item.type === 'comment' && item.comment)
+            .map((item) => item.comment);
+        return { notes, nextCursor: page.nextCursor };
+    }
+}
+
+class ProfileService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getOwnProfile(handle) {
+        const raw = await this.client.get(`/api/v1/user/${encodeURIComponent(handle)}/public_profile`);
+        return decodeOrThrow(SubstackProfileC, raw, 'SubstackProfile');
+    }
+    async getProfileBySlug(handle) {
+        const raw = await this.client.get(`/api/v1/user/${encodeURIComponent(handle)}/public_profile`);
+        return decodeOrThrow(SubstackProfileC, raw, 'SubstackProfile');
+    }
+}
+
+class CommentService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getCommentsForPost(postId, subdomain) {
+        const scope = subdomain ? { subdomain } : 'publication';
+        const raw = await this.client.get(`/api/v1/post/${postId}/comments`, { all_comments: true, sort: 'best_first' }, scope);
+        const response = decodeOrThrow(SubstackCommentsResponseC, raw, 'SubstackCommentsResponse');
+        return response.comments;
+    }
+}
+
+class FollowingService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getFollowing() {
+        var _a;
+        const raw = await this.client.get('/api/v1/subscriptions/page');
+        const response = decodeOrThrow(SubstackSubscriptionsResponseC, raw, 'SubstackSubscriptionsResponse');
+        const users = [];
+        for (const sub of response.subscriptions) {
+            const author = (_a = sub.publication) === null || _a === void 0 ? void 0 : _a.author;
+            if (author) {
+                users.push({ id: author.id, handle: author.handle });
+            }
+        }
+        return users;
+    }
+}
+
+class ConnectivityService {
+    constructor(client) {
+        this.client = client;
+    }
+    async isConnected() {
+        try {
+            // Use a lightweight profile self-check as a health probe
+            await this.client.get('/api/v1/subscriptions/page');
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+
+/**
+ * Converts a subset of markdown to Substack's Prosemirror JSON format.
+ *
+ * Supported:
+ *  - Paragraphs (double newline separated)
+ *  - Inline marks: **bold**, *italic*, ~~strikethrough~~, `code`
+ *  - Bullet lists (lines starting with - or *)
+ *  - Ordered lists (lines starting with 1. 2. etc.)
+ *  - Blockquotes (lines starting with >)
+ *
+ * Unsupported markdown passes through as plain text.
+ */
+// ─── Inline mark parsing ────────────────────────────────────────────────────
+/**
+ * Parses inline markdown marks within a single line of text.
+ * Handles: **bold**, *italic*, ~~strikethrough~~, `code`
+ * Returns an array of text nodes with appropriate marks.
+ */
+function parseInlineMarks(text) {
+    if (!text)
+        return [];
+    const nodes = [];
+    // Regex matches inline patterns in priority order:
+    // 1. **bold**  2. *italic*  3. ~~strikethrough~~  4. `code`
+    const inlinePattern = /(\*\*(.+?)\*\*|\*(.+?)\*|~~(.+?)~~|`(.+?)`)/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = inlinePattern.exec(text)) !== null) {
+        // Add any plain text before this match
+        if (match.index > lastIndex) {
+            nodes.push({ type: 'text', text: text.slice(lastIndex, match.index) });
+        }
+        if (match[2] != null) {
+            // **bold**
+            nodes.push({ type: 'text', text: match[2], marks: [{ type: 'bold' }] });
+        }
+        else if (match[3] != null) {
+            // *italic*
+            nodes.push({ type: 'text', text: match[3], marks: [{ type: 'italic' }] });
+        }
+        else if (match[4] != null) {
+            // ~~strikethrough~~
+            nodes.push({ type: 'text', text: match[4], marks: [{ type: 'strike' }] });
+        }
+        else if (match[5] != null) {
+            // `code`
+            nodes.push({ type: 'text', text: match[5], marks: [{ type: 'code' }] });
+        }
+        lastIndex = match.index + match[0].length;
+    }
+    // Add any remaining plain text
+    if (lastIndex < text.length) {
+        nodes.push({ type: 'text', text: text.slice(lastIndex) });
+    }
+    return nodes.length > 0 ? nodes : [{ type: 'text', text }];
+}
+// ─── Block parsing ──────────────────────────────────────────────────────────
+function makeParagraph(text) {
+    const content = parseInlineMarks(text);
+    return content.length > 0 ? { type: 'paragraph', content } : { type: 'paragraph' };
+}
+/**
+ * Converts a markdown string to a Prosemirror document.
+ */
+function markdownToProsemirror(markdown) {
+    const content = [];
+    const lines = markdown.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // Skip empty lines
+        if (!line.trim()) {
+            i++;
+            continue;
+        }
+        // Bullet list: collect consecutive lines starting with - or *
+        if (/^\s*[-*]\s+/.test(line)) {
+            const items = [];
+            while (i < lines.length && /^\s*[-*]\s+/.test(lines[i])) {
+                const itemText = lines[i].replace(/^\s*[-*]\s+/, '');
+                items.push({ type: 'listItem', content: [makeParagraph(itemText)] });
+                i++;
+            }
+            content.push({ type: 'bulletList', content: items });
+            continue;
+        }
+        // Ordered list: collect consecutive lines starting with digits.
+        if (/^\s*\d+[.)]\s+/.test(line)) {
+            const items = [];
+            while (i < lines.length && /^\s*\d+[.)]\s+/.test(lines[i])) {
+                const itemText = lines[i].replace(/^\s*\d+[.)]\s+/, '');
+                items.push({ type: 'listItem', content: [makeParagraph(itemText)] });
+                i++;
+            }
+            content.push({ type: 'orderedList', attrs: { start: 1, type: null }, content: items });
+            continue;
+        }
+        // Blockquote: collect consecutive lines starting with >
+        if (/^\s*>\s*/.test(line)) {
+            const quoteParagraphs = [];
+            while (i < lines.length && /^\s*>\s*/.test(lines[i])) {
+                const quoteText = lines[i].replace(/^\s*>\s*/, '');
+                if (quoteText.trim()) {
+                    quoteParagraphs.push(makeParagraph(quoteText));
+                }
+                i++;
+            }
+            if (quoteParagraphs.length > 0) {
+                content.push({ type: 'blockquote', content: quoteParagraphs });
+            }
+            continue;
+        }
+        // Regular paragraph: collect consecutive non-empty, non-special lines
+        const paraLines = [];
+        while (i < lines.length &&
+            lines[i].trim() &&
+            !/^\s*[-*]\s+/.test(lines[i]) &&
+            !/^\s*\d+[.)]\s+/.test(lines[i]) &&
+            !/^\s*>\s*/.test(lines[i])) {
+            paraLines.push(lines[i]);
+            i++;
+        }
+        if (paraLines.length > 0) {
+            content.push(makeParagraph(paraLines.join(' ')));
+        }
+    }
+    // Ensure we always have at least one node
+    if (content.length === 0) {
+        content.push({ type: 'paragraph' });
+    }
+    return {
+        type: 'doc',
+        attrs: { schemaVersion: 'v1' },
+        content
+    };
+}
+
+class NewNoteService {
+    constructor(client) {
+        this.client = client;
+    }
+    async publishNote(content, attachmentIds) {
+        const bodyJson = markdownToProsemirror(content);
+        const body = {
+            bodyJson,
+            replyMinimumRole: 'everyone'
+        };
+        if (attachmentIds && attachmentIds.length > 0) {
+            body.attachmentIds = attachmentIds;
+        }
+        const raw = await this.client.post('/api/v1/comment/feed', body);
+        return decodeOrThrow(SubstackCreateNoteResponseC, raw, 'SubstackCreateNoteResponse');
+    }
+}
+
+class SubstackClient {
+    constructor(config) {
+        this.perPage = config.perPage || 25;
+        this.handle = config.handle;
+        this.client = new HttpClient({
+            substackSid: config.substackSid,
+            substackLli: config.substackLli,
+            publicationUrl: config.publicationUrl,
+            maxRequestsPerSecond: config.maxRequestsPerSecond
+        });
+        this.postService = new PostService(this.client);
+        this.noteService = new NoteService(this.client);
+        this.profileService = new ProfileService(this.client);
+        this.commentService = new CommentService(this.client);
+        this.followingService = new FollowingService(this.client);
+        this.connectivityService = new ConnectivityService(this.client);
+        this.newNoteService = new NewNoteService(this.client);
+    }
+    async testConnectivity() {
+        return this.connectivityService.isConnected();
+    }
+    async ownProfile() {
+        if (!this.handle) {
+            throw new Error('Cannot get own profile: "handle" must be set in SubstackConfig. ' +
+                'Provide your Substack handle (e.g. "myname") in the config.');
+        }
+        try {
+            const profile = await this.profileService.getOwnProfile(this.handle);
+            return new OwnProfile(profile, this.postService, this.noteService, this.commentService, this.profileService, this.followingService, this.newNoteService, this.perPage);
+        }
+        catch (error) {
+            throw new Error(`Failed to get own profile: ${error.message}`);
+        }
+    }
+    async profileForHandle(handle) {
+        if (!handle || handle.trim() === '') {
+            throw new Error('Profile handle cannot be empty');
+        }
+        try {
+            const profile = await this.profileService.getProfileBySlug(handle);
+            return new Profile(profile, this.postService, this.noteService, this.commentService, this.perPage);
+        }
+        catch (error) {
+            throw new Error(`Profile with handle '${handle}' not found: ${error.message}`);
+        }
+    }
+    async postForSlug(slug, publicationSubdomain) {
+        try {
+            const post = await this.postService.getPostBySlug(slug, publicationSubdomain);
+            return new FullPost(post, this.commentService, publicationSubdomain);
+        }
+        catch (error) {
+            throw new Error(`Post with slug '${slug}' not found: ${error.message}`);
+        }
+    }
+    async close() {
+        await this.client.close();
+    }
+}
+
+exports.Comment = Comment;
+exports.FullPost = FullPost;
+exports.Note = Note;
+exports.OwnProfile = OwnProfile;
+exports.PreviewPost = PreviewPost;
+exports.Profile = Profile;
+exports.SubstackClient = SubstackClient;